@pendle/core-v2 0.13.0-testnet → 0.14.0-testnet

package/typechain-types/IPActionSwapYT.ts

@@ -48,44 +48,44 @@ export type ApproxParamsStructOutput = [
 export type TokenInputStruct = {
   tokenIn: string;
   netTokenIn: BigNumberish;
-  tokenMintScy: string;
+  tokenMintSy: string;
   kybercall: BytesLike;
 };
 
 export type TokenInputStructOutput = [string, BigNumber, string, string] & {
   tokenIn: string;
   netTokenIn: BigNumber;
-  tokenMintScy: string;
+  tokenMintSy: string;
   kybercall: string;
 };
 
 export type TokenOutputStruct = {
   tokenOut: string;
   minTokenOut: BigNumberish;
-  tokenRedeemScy: string;
+  tokenRedeemSy: string;
   kybercall: BytesLike;
 };
 
 export type TokenOutputStructOutput = [string, BigNumber, string, string] & {
   tokenOut: string;
   minTokenOut: BigNumber;
-  tokenRedeemScy: string;
+  tokenRedeemSy: string;
   kybercall: string;
 };
 
 export interface IPActionSwapYTInterface extends utils.Interface {
   contractName: "IPActionSwapYT";
   functions: {
-    "swapExactScyForYt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapExactSyForYt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapExactTokenForYt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
-    "swapExactYtForScy(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactYtForSy(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;
+    "swapSyForExactYt(address,address,uint256,uint256)": FunctionFragment;
+    "swapYtForExactSy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "swapExactScyForYt",
+    functionFragment: "swapExactSyForYt",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
@@ -93,7 +93,7 @@ export interface IPActionSwapYTInterface extends utils.Interface {
     values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactYtForScy",
+    functionFragment: "swapExactYtForSy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
@@ -101,16 +101,16 @@ export interface IPActionSwapYTInterface extends utils.Interface {
     values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForExactYt",
+    functionFragment: "swapSyForExactYt",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapYtForExactScy",
+    functionFragment: "swapYtForExactSy",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "swapExactScyForYt",
+    functionFragment: "swapExactSyForYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -118,7 +118,7 @@ export interface IPActionSwapYTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactYtForScy",
+    functionFragment: "swapExactYtForSy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -126,35 +126,35 @@ export interface IPActionSwapYTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactYt",
+    functionFragment: "swapSyForExactYt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapYtForExactScy",
+    functionFragment: "swapYtForExactSy",
     data: BytesLike
   ): Result;
 
   events: {
-    "SwapYtAndScy(address,address,address,int256,int256)": EventFragment;
+    "SwapYtAndSy(address,address,address,int256,int256)": EventFragment;
     "SwapYtAndToken(address,address,address,address,int256,int256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "SwapYtAndScy"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SwapYtAndSy"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "SwapYtAndToken"): EventFragment;
 }
 
-export type SwapYtAndScyEvent = TypedEvent<
+export type SwapYtAndSyEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber],
   {
     caller: string;
     market: string;
     receiver: string;
     netYtToAccount: BigNumber;
-    netScyToAccount: BigNumber;
+    netSyToAccount: BigNumber;
   }
 >;
 
-export type SwapYtAndScyEventFilter = TypedEventFilter<SwapYtAndScyEvent>;
+export type SwapYtAndSyEventFilter = TypedEventFilter<SwapYtAndSyEvent>;
 
 export type SwapYtAndTokenEvent = TypedEvent<
   [string, string, string, string, BigNumber, BigNumber],
@@ -198,10 +198,10 @@ export interface IPActionSwapYT extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    swapExactScyForYt(
+    swapExactSyForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -216,11 +216,11 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForSy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -232,28 +232,28 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapScyForExactYt(
+    swapSyForExactYt(
       receiver: string,
       market: string,
       exactYtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapYtForExactScy(
+    swapYtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxYtIn: BigNumberish,
       guessYtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
-  swapExactScyForYt(
+  swapExactSyForYt(
     receiver: string,
     market: string,
-    exactScyIn: BigNumberish,
+    exactSyIn: BigNumberish,
     minYtOut: BigNumberish,
     guessYtOut: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -268,11 +268,11 @@ export interface IPActionSwapYT extends BaseContract {
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactYtForScy(
+  swapExactYtForSy(
     receiver: string,
     market: string,
     exactYtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    minSyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -284,33 +284,33 @@ export interface IPActionSwapYT extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapScyForExactYt(
+  swapSyForExactYt(
     receiver: string,
     market: string,
     exactYtOut: BigNumberish,
-    maxScyIn: BigNumberish,
+    maxSyIn: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapYtForExactScy(
+  swapYtForExactSy(
     receiver: string,
     market: string,
-    exactScyOut: BigNumberish,
+    exactSyOut: BigNumberish,
     maxYtIn: BigNumberish,
     guessYtIn: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    swapExactScyForYt(
+    swapExactSyForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netYtOut: BigNumber; netSyFee: BigNumber }
     >;
 
     swapExactTokenForYt(
@@ -321,17 +321,17 @@ export interface IPActionSwapYT extends BaseContract {
       input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netYtOut: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapExactYtForScy(
+    swapExactYtForSy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netSyOut: BigNumber; netSyFee: BigNumber }
     >;
 
     swapExactYtForToken(
@@ -341,46 +341,46 @@ export interface IPActionSwapYT extends BaseContract {
       output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netTokenOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netTokenOut: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapScyForExactYt(
+    swapSyForExactYt(
       receiver: string,
       market: string,
       exactYtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netSyIn: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapYtForExactScy(
+    swapYtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxYtIn: BigNumberish,
       guessYtIn: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netYtIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netYtIn: BigNumber; netSyFee: BigNumber }
     >;
   };
 
   filters: {
-    "SwapYtAndScy(address,address,address,int256,int256)"(
+    "SwapYtAndSy(address,address,address,int256,int256)"(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
       netYtToAccount?: null,
-      netScyToAccount?: null
-    ): SwapYtAndScyEventFilter;
-    SwapYtAndScy(
+      netSyToAccount?: null
+    ): SwapYtAndSyEventFilter;
+    SwapYtAndSy(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
       netYtToAccount?: null,
-      netScyToAccount?: null
-    ): SwapYtAndScyEventFilter;
+      netSyToAccount?: null
+    ): SwapYtAndSyEventFilter;
 
     "SwapYtAndToken(address,address,address,address,int256,int256)"(
       caller?: string | null,
@@ -401,10 +401,10 @@ export interface IPActionSwapYT extends BaseContract {
   };
 
   estimateGas: {
-    swapExactScyForYt(
+    swapExactSyForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -419,11 +419,11 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactYtForScy(
+    swapExactYtForSy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -435,18 +435,18 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapScyForExactYt(
+    swapSyForExactYt(
       receiver: string,
       market: string,
       exactYtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapYtForExactScy(
+    swapYtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxYtIn: BigNumberish,
       guessYtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -454,10 +454,10 @@ export interface IPActionSwapYT extends BaseContract {
   };
 
   populateTransaction: {
-    swapExactScyForYt(
+    swapExactSyForYt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minYtOut: BigNumberish,
       guessYtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -472,11 +472,11 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactYtForScy(
+    swapExactYtForSy(
       receiver: string,
       market: string,
       exactYtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -488,18 +488,18 @@ export interface IPActionSwapYT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapScyForExactYt(
+    swapSyForExactYt(
       receiver: string,
       market: string,
       exactYtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapYtForExactScy(
+    swapYtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxYtIn: BigNumberish,
       guessYtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }