@pendle/core-v2 0.8.1-beta → 0.9.0-gamma-2

package/typechain-types/IPActionYT.ts

@@ -44,40 +44,61 @@ export type ApproxParamsStructOutput = [
   eps: BigNumber;
 };
 
+export type TokenInputStruct = {
+  tokenIn: string;
+  netTokenIn: BigNumberish;
+  tokenMintScy: string;
+  kybercall: BytesLike;
+};
+
+export type TokenInputStructOutput = [string, BigNumber, string, string] & {
+  tokenIn: string;
+  netTokenIn: BigNumber;
+  tokenMintScy: string;
+  kybercall: string;
+};
+
+export type TokenOutputStruct = {
+  tokenOut: string;
+  minTokenOut: BigNumberish;
+  tokenRedeemScy: string;
+  kybercall: BytesLike;
+};
+
+export type TokenOutputStructOutput = [string, BigNumber, string, string] & {
+  tokenOut: string;
+  minTokenOut: BigNumber;
+  tokenRedeemScy: string;
+  kybercall: string;
+};
+
 export interface IPActionYTInterface extends utils.Interface {
   contractName: "IPActionYT";
   functions: {
-    "swapExactRawTokenForYt(address,address,uint256,uint256,address[],(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapExactScyForYt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapExactYtForRawToken(address,address,uint256,uint256,address[])": FunctionFragment;
+    "swapExactTokenForYt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
     "swapExactYtForScy(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactYtForToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
     "swapScyForExactYt(address,address,uint256,uint256)": FunctionFragment;
     "swapYtForExactScy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
   };
 
-  encodeFunctionData(
-    functionFragment: "swapExactRawTokenForYt",
-    values: [
-      string,
-      string,
-      BigNumberish,
-      BigNumberish,
-      string[],
-      ApproxParamsStruct
-    ]
-  ): string;
   encodeFunctionData(
     functionFragment: "swapExactScyForYt",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactYtForRawToken",
-    values: [string, string, BigNumberish, BigNumberish, string[]]
+    functionFragment: "swapExactTokenForYt",
+    values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
   encodeFunctionData(
     functionFragment: "swapExactYtForScy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "swapExactYtForToken",
+    values: [string, string, BigNumberish, TokenOutputStruct]
+  ): string;
   encodeFunctionData(
     functionFragment: "swapScyForExactYt",
     values: [string, string, BigNumberish, BigNumberish]
@@ -88,19 +109,19 @@ export interface IPActionYTInterface extends utils.Interface {
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForYt",
+    functionFragment: "swapExactScyForYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForYt",
+    functionFragment: "swapExactTokenForYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactYtForRawToken",
+    functionFragment: "swapExactYtForScy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactYtForScy",
+    functionFragment: "swapExactYtForToken",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -113,39 +134,38 @@ export interface IPActionYTInterface extends utils.Interface {
   ): Result;
 
   events: {
-    "SwapYTAndRawToken(address,address,address,int256,int256)": EventFragment;
     "SwapYTAndSCY(address,address,int256,int256)": EventFragment;
+    "SwapYTAndToken(address,address,address,int256,int256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "SwapYTAndRawToken"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "SwapYTAndSCY"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SwapYTAndToken"): EventFragment;
 }
 
-export type SwapYTAndRawTokenEvent = TypedEvent<
-  [string, string, string, BigNumber, BigNumber],
+export type SwapYTAndSCYEvent = TypedEvent<
+  [string, string, BigNumber, BigNumber],
   {
     user: string;
     market: string;
-    rawToken: string;
     ytToAccount: BigNumber;
-    rawTokenToAccount: BigNumber;
+    scyToAccount: BigNumber;
   }
 >;
 
-export type SwapYTAndRawTokenEventFilter =
-  TypedEventFilter<SwapYTAndRawTokenEvent>;
+export type SwapYTAndSCYEventFilter = TypedEventFilter<SwapYTAndSCYEvent>;
 
-export type SwapYTAndSCYEvent = TypedEvent<
-  [string, string, BigNumber, BigNumber],
+export type SwapYTAndTokenEvent = TypedEvent<
+  [string, string, string, BigNumber, BigNumber],
   {
     user: string;
     market: string;
+    token: string;
     ytToAccount: BigNumber;
-    scyToAccount: BigNumber;
+    tokenToAccount: BigNumber;
   }
 >;
 
-export type SwapYTAndSCYEventFilter = TypedEventFilter<SwapYTAndSCYEvent>;
+export type SwapYTAndTokenEventFilter = TypedEventFilter<SwapYTAndTokenEvent>;
 
 export interface IPActionYT extends BaseContract {
   contractName: "IPActionYT";
@@ -175,39 +195,37 @@ export interface IPActionYT extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -229,39 +247,37 @@ export interface IPActionYT extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
-  swapExactRawTokenForYt(
+  swapExactScyForYt(
     receiver: string,
     market: string,
-    exactRawTokenIn: BigNumberish,
+    exactScyIn: BigNumberish,
     minYtOut: BigNumberish,
-    path: string[],
     guessYtOut: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForYt(
+  swapExactTokenForYt(
     receiver: string,
     market: string,
-    exactScyIn: BigNumberish,
     minYtOut: BigNumberish,
     guessYtOut: ApproxParamsStruct,
+    input: TokenInputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactYtForRawToken(
+  swapExactYtForScy(
     receiver: string,
     market: string,
     exactYtIn: BigNumberish,
-    minRawTokenOut: BigNumberish,
-    path: string[],
+    minScyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactYtForScy(
+  swapExactYtForToken(
     receiver: string,
     market: string,
-    exactYtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    netYtIn: BigNumberish,
+    output: TokenOutputStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -283,39 +299,37 @@ export interface IPActionYT extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
@@ -338,69 +352,67 @@ export interface IPActionYT extends BaseContract {
   };
 
   filters: {
-    "SwapYTAndRawToken(address,address,address,int256,int256)"(
+    "SwapYTAndSCY(address,address,int256,int256)"(
       user?: string | null,
       market?: string | null,
-      rawToken?: string | null,
       ytToAccount?: null,
-      rawTokenToAccount?: null
-    ): SwapYTAndRawTokenEventFilter;
-    SwapYTAndRawToken(
+      scyToAccount?: null
+    ): SwapYTAndSCYEventFilter;
+    SwapYTAndSCY(
       user?: string | null,
       market?: string | null,
-      rawToken?: string | null,
       ytToAccount?: null,
-      rawTokenToAccount?: null
-    ): SwapYTAndRawTokenEventFilter;
+      scyToAccount?: null
+    ): SwapYTAndSCYEventFilter;
 
-    "SwapYTAndSCY(address,address,int256,int256)"(
+    "SwapYTAndToken(address,address,address,int256,int256)"(
       user?: string | null,
       market?: string | null,
+      token?: string | null,
       ytToAccount?: null,
-      scyToAccount?: null
-    ): SwapYTAndSCYEventFilter;
-    SwapYTAndSCY(
+      tokenToAccount?: null
+    ): SwapYTAndTokenEventFilter;
+    SwapYTAndToken(
       user?: string | null,
       market?: string | null,
+      token?: string | null,
       ytToAccount?: null,
-      scyToAccount?: null
-    ): SwapYTAndSCYEventFilter;
+      tokenToAccount?: null
+    ): SwapYTAndTokenEventFilter;
   };
 
   estimateGas: {
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -423,39 +435,37 @@ export interface IPActionYT extends BaseContract {
   };
 
   populateTransaction: {
-    swapExactRawTokenForYt(
+    swapExactScyForYt(
       receiver: string,
       market: string,
-      exactRawTokenIn: BigNumberish,
+      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
-      path: string[],
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForYt(
+    swapExactTokenForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
+      input: TokenInputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactYtForRawToken(
+    swapExactYtForScy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minRawTokenOut: BigNumberish,
-      path: string[],
+      minScyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForToken(
       receiver: string,
       market: string,
-      exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      netYtIn: BigNumberish,
+      output: TokenOutputStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;