@pendle/core-v2 0.8.1-gamma → 0.9.2-beta

package/typechain-types/ActionSCYAndPTBase.ts

@@ -22,15 +22,18 @@ import type {
 export interface ActionSCYAndPTBaseInterface extends utils.Interface {
   contractName: "ActionSCYAndPTBase";
   functions: {
-    "joeFactory()": FunctionFragment;
+    "kyberSwapRouter()": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "joeFactory",
+    functionFragment: "kyberSwapRouter",
     values?: undefined
   ): string;
 
-  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "kyberSwapRouter",
+    data: BytesLike
+  ): Result;
 
   events: {};
 }
@@ -63,22 +66,22 @@ export interface ActionSCYAndPTBase extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<[string]>;
   };
 
-  joeFactory(overrides?: CallOverrides): Promise<string>;
+  kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
-    joeFactory(overrides?: CallOverrides): Promise<string>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/ActionSCYAndPYBase.ts

@@ -22,15 +22,18 @@ import type {
 export interface ActionSCYAndPYBaseInterface extends utils.Interface {
   contractName: "ActionSCYAndPYBase";
   functions: {
-    "joeFactory()": FunctionFragment;
+    "kyberSwapRouter()": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "joeFactory",
+    functionFragment: "kyberSwapRouter",
     values?: undefined
   ): string;
 
-  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "kyberSwapRouter",
+    data: BytesLike
+  ): Result;
 
   events: {};
 }
@@ -63,22 +66,22 @@ export interface ActionSCYAndPYBase extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<[string]>;
   };
 
-  joeFactory(overrides?: CallOverrides): Promise<string>;
+  kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
-    joeFactory(overrides?: CallOverrides): Promise<string>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/ActionSCYAndYTBase.ts

@@ -22,15 +22,18 @@ import type {
 export interface ActionSCYAndYTBaseInterface extends utils.Interface {
   contractName: "ActionSCYAndYTBase";
   functions: {
-    "joeFactory()": FunctionFragment;
+    "kyberSwapRouter()": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "joeFactory",
+    functionFragment: "kyberSwapRouter",
     values?: undefined
   ): string;
 
-  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "kyberSwapRouter",
+    data: BytesLike
+  ): Result;
 
   events: {};
 }
@@ -63,22 +66,22 @@ export interface ActionSCYAndYTBase extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<[string]>;
   };
 
-  joeFactory(overrides?: CallOverrides): Promise<string>;
+  kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
   callStatic: {
-    joeFactory(overrides?: CallOverrides): Promise<string>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
   };
 
   filters: {};
 
   estimateGas: {
-    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }

package/typechain-types/ActionYT.ts

@@ -44,45 +44,66 @@ 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 ActionYTInterface extends utils.Interface {
   contractName: "ActionYT";
   functions: {
-    "joeFactory()": FunctionFragment;
-    "swapExactRawTokenForYt(address,address,uint256,uint256,address[],(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "kyberSwapRouter()": 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: "joeFactory",
+    functionFragment: "kyberSwapRouter",
     values?: undefined
   ): string;
-  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]
@@ -92,9 +113,8 @@ export interface ActionYTInterface extends utils.Interface {
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
 
-  decodeFunctionResult(functionFragment: "joeFactory", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactRawTokenForYt",
+    functionFragment: "kyberSwapRouter",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -102,13 +122,17 @@ export interface ActionYTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactYtForRawToken",
+    functionFragment: "swapExactTokenForYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
     functionFragment: "swapExactYtForScy",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(
+    functionFragment: "swapExactYtForToken",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(
     functionFragment: "swapScyForExactYt",
     data: BytesLike
@@ -119,39 +143,38 @@ export interface ActionYTInterface 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 ActionYT extends BaseContract {
   contractName: "ActionYT";
@@ -181,41 +204,39 @@ export interface ActionYT extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    joeFactory(overrides?: CallOverrides): Promise<[string]>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<[string]>;
 
-    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>;
 
@@ -237,41 +258,39 @@ export interface ActionYT extends BaseContract {
     ): Promise<ContractTransaction>;
   };
 
-  joeFactory(overrides?: CallOverrides): Promise<string>;
+  kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
-  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>;
 
@@ -293,41 +312,39 @@ export interface ActionYT extends BaseContract {
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    joeFactory(overrides?: CallOverrides): Promise<string>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
-    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>;
 
@@ -350,71 +367,69 @@ export interface ActionYT 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: {
-    joeFactory(overrides?: CallOverrides): Promise<BigNumber>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<BigNumber>;
 
-    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>;
 
@@ -437,41 +452,39 @@ export interface ActionYT extends BaseContract {
   };
 
   populateTransaction: {
-    joeFactory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    kyberSwapRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    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>;