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

package/typechain-types/IPActionSwapPT.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,30 +62,30 @@ 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 interface IPActionSwapPTInterface extends utils.Interface {
   contractName: "IPActionSwapPT";
   functions: {
-    "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(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactPtForSy",
     values: [string, string, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(
@@ -93,7 +93,7 @@ export interface IPActionSwapPTInterface extends utils.Interface {
     values: [string, string, BigNumberish, TokenOutputStruct]
   ): string;
   encodeFunctionData(
-    functionFragment: "swapExactScyForPt",
+    functionFragment: "swapExactSyForPt",
     values: [string, string, BigNumberish, BigNumberish, ApproxParamsStruct]
   ): string;
   encodeFunctionData(
@@ -101,16 +101,16 @@ export interface IPActionSwapPTInterface 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;
 
   decodeFunctionResult(
-    functionFragment: "swapExactPtForScy",
+    functionFragment: "swapExactPtForSy",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -118,7 +118,7 @@ export interface IPActionSwapPTInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "swapExactScyForPt",
+    functionFragment: "swapExactSyForPt",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -126,35 +126,35 @@ export interface IPActionSwapPTInterface 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],
@@ -198,11 +198,11 @@ export interface IPActionSwapPT extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
@@ -214,10 +214,10 @@ export interface IPActionSwapPT 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> }
@@ -232,29 +232,29 @@ export interface IPActionSwapPT 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>;
   };
 
-  swapExactPtForScy(
+  swapExactPtForSy(
     receiver: string,
     market: string,
     exactPtIn: BigNumberish,
-    minScyOut: BigNumberish,
+    minSyOut: BigNumberish,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
@@ -266,10 +266,10 @@ export interface IPActionSwapPT 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> }
@@ -284,32 +284,32 @@ export interface IPActionSwapPT 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: {
-    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(
@@ -319,18 +319,18 @@ export interface IPActionSwapPT 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(
@@ -341,46 +341,46 @@ export interface IPActionSwapPT 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,
@@ -401,11 +401,11 @@ export interface IPActionSwapPT extends BaseContract {
   };
 
   estimateGas: {
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
@@ -417,10 +417,10 @@ export interface IPActionSwapPT 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> }
@@ -435,30 +435,30 @@ export interface IPActionSwapPT 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>;
   };
 
   populateTransaction: {
-    swapExactPtForScy(
+    swapExactPtForSy(
       receiver: string,
       market: string,
       exactPtIn: BigNumberish,
-      minScyOut: BigNumberish,
+      minSyOut: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
@@ -470,10 +470,10 @@ export interface IPActionSwapPT 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> }
@@ -488,20 +488,20 @@ export interface IPActionSwapPT 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/IPActionSwapPTYT.ts

@@ -163,7 +163,7 @@ export interface IPActionSwapPTYT 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 IPActionSwapPTYT extends BaseContract {
       guessTotalPtSwapped: ApproxParamsStruct,
       overrides?: CallOverrides
     ): Promise<
-      [BigNumber, BigNumber] & { netPtOut: BigNumber; netScyFee: BigNumber }
+      [BigNumber, BigNumber] & { netPtOut: BigNumber; netSyFee: BigNumber }
     >;
   };