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

package/typechain-types/ActionSwapPT.ts

@@ -26,14 +26,14 @@ import type {
 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;
 };
 
@@ -62,14 +62,14 @@ 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;
 };
 
@@ -77,12 +77,12 @@ export interface ActionSwapPTInterface extends utils.Interface {
   contractName: "ActionSwapPT";
   functions: {
     "kyberSwapRouter()": FunctionFragment;
-    "swapExactPtForScy(address,address,uint256,uint256)": FunctionFragment;
+    "swapExactPtForSy(address,address,uint256,uint256)": FunctionFragment;
     "swapExactPtForToken(address,address,uint256,(address,uint256,address,bytes))": FunctionFragment;
-    "swapExactScyForPt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapExactSyForPt(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
     "swapExactTokenForPt(address,address,uint256,(uint256,uint256,uint256,uint256,uint256),(address,uint256,address,bytes))": FunctionFragment;
-    "swapPtForExactScy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
-    "swapScyForExactPt(address,address,uint256,uint256)": FunctionFragment;
+    "swapPtForExactSy(address,address,uint256,uint256,(uint256,uint256,uint256,uint256,uint256))": FunctionFragment;
+    "swapSyForExactPt(address,address,uint256,uint256)": FunctionFragment;
   };
 
   encodeFunctionData(
@@ -90,7 +90,7 @@ export interface ActionSwapPTInterface extends utils.Interface {
     values?: undefined
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactPtForSy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
@@ -98,7 +98,7 @@ export interface ActionSwapPTInterface extends utils.Interface {
     values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactScyForPt",
+    functionFragment: "swapExactSyForPt",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
@@ -106,11 +106,11 @@ export interface ActionSwapPTInterface extends utils.Interface {
     values: [string, string, BigNumberish, ApproxParamsStruct, TokenInputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapPtForExactScy",
+    functionFragment: "swapPtForExactSy",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapScyForExactPt",
+    functionFragment: "swapSyForExactPt",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
 
@@ -119,7 +119,7 @@ export interface ActionSwapPTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactPtForSy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -127,7 +127,7 @@ export interface ActionSwapPTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForPt",
+    functionFragment: "swapExactSyForPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -135,35 +135,35 @@ export interface ActionSwapPTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapPtForExactScy",
+    functionFragment: "swapPtForExactSy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapScyForExactPt",
+    functionFragment: "swapSyForExactPt",
     data: BytesLike
   ): Result;
 
   events: {
-    "SwapPtAndScy(address,address,address,int256,int256)": EventFragment;
+    "SwapPtAndSy(address,address,address,int256,int256)": EventFragment;
     "SwapPtAndToken(address,address,address,address,int256,int256)": EventFragment;
   };
 
-  getEvent(nameOrSignatureOrTopic: "SwapPtAndScy"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "SwapPtAndSy"): EventFragment;
   getEvent(nameOrSignatureOrTopic: "SwapPtAndToken"): EventFragment;
 }
 
-export type SwapPtAndScyEvent = TypedEvent<
+export type SwapPtAndSyEvent = TypedEvent<
   [string, string, string, BigNumber, BigNumber],
   {
     caller: string;
     market: string;
     receiver: string;
     netPtToAccount: BigNumber;
-    netScyToAccount: BigNumber;
+    netSyToAccount: BigNumber;
   }
 >;
 
-export type SwapPtAndScyEventFilter = TypedEventFilter<SwapPtAndScyEvent>;
+export type SwapPtAndSyEventFilter = TypedEventFilter<SwapPtAndSyEvent>;
 
 export type SwapPtAndTokenEvent = TypedEvent<
   [string, string, string, string, BigNumber, BigNumber],
@@ -209,11 +209,11 @@ export interface ActionSwapPT extends BaseContract {
   functions: {
     kyberSwapRouter(overrides?: CallOverrides): Promise<[string]>;
 
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -225,10 +225,10 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapExactScyForPt(
+    swapExactSyForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -243,31 +243,31 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapPtForExactScy(
+    swapPtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxPtIn: BigNumberish,
       guessPtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    swapScyForExactPt(
+    swapSyForExactPt(
       receiver: string,
       market: string,
       exactPtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
   kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
-  swapExactPtForScy(
+  swapExactPtForSy(
     receiver: string,
     market: string,
     exactPtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    minSyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -279,10 +279,10 @@ export interface ActionSwapPT extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapExactScyForPt(
+  swapExactSyForPt(
     receiver: string,
     market: string,
-    exactScyIn: BigNumberish,
+    exactSyIn: BigNumberish,
     minPtOut: BigNumberish,
     guessPtOut: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
@@ -297,34 +297,34 @@ export interface ActionSwapPT extends BaseContract {
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapPtForExactScy(
+  swapPtForExactSy(
     receiver: string,
     market: string,
-    exactScyOut: BigNumberish,
+    exactSyOut: BigNumberish,
     maxPtIn: BigNumberish,
     guessPtIn: ApproxParamsStruct,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  swapScyForExactPt(
+  swapSyForExactPt(
     receiver: string,
     market: string,
     exactPtOut: BigNumberish,
-    maxScyIn: BigNumberish,
+    maxSyIn: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
     kyberSwapRouter(overrides?: CallOverrides): Promise<string>;
 
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netSyOut: BigNumber; netSyFee: BigNumber }
     >;
 
     swapExactPtForToken(
@@ -334,18 +334,18 @@ export interface ActionSwapPT extends BaseContract {
       output: TokenOutputStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netTokenOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netTokenOut: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapExactScyForPt(
+    swapExactSyForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netSyFee: BigNumber }
     >;
 
     swapExactTokenForPt(
@@ -356,46 +356,46 @@ export interface ActionSwapPT extends BaseContract {
       input: TokenInputStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapPtForExactScy(
+    swapPtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxPtIn: BigNumberish,
       guessPtIn: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netPtIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtIn: BigNumber; netSyFee: BigNumber }
     >;
 
-    swapScyForExactPt(
+    swapSyForExactPt(
       receiver: string,
       market: string,
       exactPtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netScyIn: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netSyIn: BigNumber; netSyFee: BigNumber }
     >;
   };
 
   filters: {
-    "SwapPtAndScy(address,address,address,int256,int256)"(
+    "SwapPtAndSy(address,address,address,int256,int256)"(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
       netPtToAccount?: null,
-      netScyToAccount?: null
-    ): SwapPtAndScyEventFilter;
-    SwapPtAndScy(
+      netSyToAccount?: null
+    ): SwapPtAndSyEventFilter;
+    SwapPtAndSy(
       caller?: string | null,
       market?: string | null,
       receiver?: string | null,
       netPtToAccount?: null,
-      netScyToAccount?: null
-    ): SwapPtAndScyEventFilter;
+      netSyToAccount?: null
+    ): SwapPtAndSyEventFilter;
 
     "SwapPtAndToken(address,address,address,address,int256,int256)"(
       caller?: string | null,
@@ -418,11 +418,11 @@ export interface ActionSwapPT extends BaseContract {
   estimateGas: {
     kyberSwapRouter(overrides?: CallOverrides): Promise<BigNumber>;
 
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -434,10 +434,10 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapExactScyForPt(
+    swapExactSyForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -452,20 +452,20 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapPtForExactScy(
+    swapPtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxPtIn: BigNumberish,
       guessPtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    swapScyForExactPt(
+    swapSyForExactPt(
       receiver: string,
       market: string,
       exactPtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
@@ -473,11 +473,11 @@ export interface ActionSwapPT extends BaseContract {
   populateTransaction: {
     kyberSwapRouter(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -489,10 +489,10 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapExactScyForPt(
+    swapExactSyForPt(
       receiver: string,
       market: string,
-      exactScyIn: BigNumberish,
+      exactSyIn: BigNumberish,
       minPtOut: BigNumberish,
       guessPtOut: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
@@ -507,20 +507,20 @@ export interface ActionSwapPT extends BaseContract {
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapPtForExactScy(
+    swapPtForExactSy(
       receiver: string,
       market: string,
-      exactScyOut: BigNumberish,
+      exactSyOut: BigNumberish,
       maxPtIn: BigNumberish,
       guessPtIn: ApproxParamsStruct,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    swapScyForExactPt(
+    swapSyForExactPt(
       receiver: string,
       market: string,
       exactPtOut: BigNumberish,
-      maxScyIn: BigNumberish,
+      maxSyIn: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };

package/typechain-types/ActionSwapPTYT.ts

@@ -163,7 +163,7 @@ export interface ActionSwapPTYT extends BaseContract {
       guessTotalPtToSwap: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netYtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netYtOut: BigNumber; netSyFee: BigNumber }
     >;
 
     swapExactYtForPt(
@@ -174,7 +174,7 @@ export interface ActionSwapPTYT extends BaseContract {
       guessTotalPtSwapped: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netSyFee: BigNumber }
     >;
   };