@pendle/core-v2 2.26.1 → 2.26.2

package/typechain-types/IExecutorHelper.ts

@@ -25,136 +25,129 @@ import type {
 export interface IExecutorHelperInterface extends utils.Interface {
   contractName: "IExecutorHelper";
   functions: {
-    "executeBalV2(bytes,uint256)": FunctionFragment;
-    "executeCamelot(bytes,uint256)": FunctionFragment;
-    "executeCurve(bytes,uint256)": FunctionFragment;
-    "executeDODO(bytes,uint256)": FunctionFragment;
-    "executeFrax(bytes,uint256)": FunctionFragment;
-    "executeGMX(bytes,uint256)": FunctionFragment;
-    "executeHashflow(bytes,uint256)": FunctionFragment;
-    "executeKSClassic(bytes,uint256)": FunctionFragment;
-    "executeKyberLimitOrder(bytes,uint256)": FunctionFragment;
-    "executeMaverick(bytes,uint256)": FunctionFragment;
-    "executePSM(bytes,uint256)": FunctionFragment;
-    "executePlatypus(bytes,uint256)": FunctionFragment;
-    "executeRfq(bytes,uint256)": FunctionFragment;
-    "executeStEth(bytes,uint256)": FunctionFragment;
-    "executeStableSwap(bytes,uint256)": FunctionFragment;
-    "executeSynthetix(bytes,uint256)": FunctionFragment;
-    "executeUniV3KSElastic(bytes,uint256)": FunctionFragment;
-    "executeUniswap(bytes,uint256)": FunctionFragment;
-    "executeVelodrome(bytes,uint256)": FunctionFragment;
-    "executeWrappedstETH(bytes,uint256)": FunctionFragment;
+    "executeBalV2Swap(uint256,bytes,uint256)": FunctionFragment;
+    "executeCamelotSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeCurveSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeDODOSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeFraxSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeGMXSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeHashflowSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeKyberDMMSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeKyberLimitOrder(uint256,bytes,uint256)": FunctionFragment;
+    "executePSMSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executePlatypusSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeRfqSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeStableSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeSynthetixSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeUniSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeUniV3ProMMSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeVelodromeSwap(uint256,bytes,uint256)": FunctionFragment;
+    "executeWrappedstETHSwap(uint256,bytes,uint256)": FunctionFragment;
   };
 
   encodeFunctionData(
-    functionFragment: "executeBalV2",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeBalV2Swap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeCamelot",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeCamelotSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeCurve",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeCurveSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeDODO",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeDODOSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeFrax",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeFraxSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeGMX",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeGMXSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeHashflow",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeHashflowSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeKSClassic",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeKyberDMMSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "executeKyberLimitOrder",
-    values: [BytesLike, BigNumberish]
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeMaverick",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executePSMSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executePSM",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executePlatypusSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executePlatypus",
-    values: [BytesLike, BigNumberish]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "executeRfq",
-    values: [BytesLike, BigNumberish]
-  ): string;
-  encodeFunctionData(
-    functionFragment: "executeStEth",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeRfqSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
     functionFragment: "executeStableSwap",
-    values: [BytesLike, BigNumberish]
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeSynthetix",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeSynthetixSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeUniV3KSElastic",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeUniSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeUniswap",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeUniV3ProMMSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeVelodrome",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeVelodromeSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
   encodeFunctionData(
-    functionFragment: "executeWrappedstETH",
-    values: [BytesLike, BigNumberish]
+    functionFragment: "executeWrappedstETHSwap",
+    values: [BigNumberish, BytesLike, BigNumberish]
   ): string;
 
   decodeFunctionResult(
-    functionFragment: "executeBalV2",
+    functionFragment: "executeBalV2Swap",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "executeCamelotSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeCamelot",
+    functionFragment: "executeCurveSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeCurve",
+    functionFragment: "executeDODOSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeDODO",
+    functionFragment: "executeFraxSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeFrax",
+    functionFragment: "executeGMXSwap",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "executeGMX", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "executeHashflow",
+    functionFragment: "executeHashflowSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeKSClassic",
+    functionFragment: "executeKyberDMMSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -162,17 +155,15 @@ export interface IExecutorHelperInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeMaverick",
+    functionFragment: "executePSMSwap",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "executePSM", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "executePlatypus",
+    functionFragment: "executePlatypusSwap",
     data: BytesLike
   ): Result;
-  decodeFunctionResult(functionFragment: "executeRfq", data: BytesLike): Result;
   decodeFunctionResult(
-    functionFragment: "executeStEth",
+    functionFragment: "executeRfqSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
@@ -180,23 +171,23 @@ export interface IExecutorHelperInterface extends utils.Interface {
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeSynthetix",
+    functionFragment: "executeSynthetixSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeUniV3KSElastic",
+    functionFragment: "executeUniSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeUniswap",
+    functionFragment: "executeUniV3ProMMSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeVelodrome",
+    functionFragment: "executeVelodromeSwap",
     data: BytesLike
   ): Result;
   decodeFunctionResult(
-    functionFragment: "executeWrappedstETH",
+    functionFragment: "executeWrappedstETHSwap",
     data: BytesLike
   ): Result;
 
@@ -231,365 +222,383 @@ export interface IExecutorHelper extends BaseContract {
   removeListener: OnEvent<this>;
 
   functions: {
-    executeBalV2(
+    executeBalV2Swap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeCamelot(
+    executeCamelotSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeCurve(
+    executeCurveSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeDODO(
+    executeDODOSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeFrax(
+    executeFraxSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeGMX(
+    executeGMXSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeHashflow(
+    executeHashflowSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeKSClassic(
+    executeKyberDMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
     executeKyberLimitOrder(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    executeMaverick(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<ContractTransaction>;
-
-    executePSM(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executePlatypus(
+    executePSMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeRfq(
+    executePlatypusSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeStEth(
+    executeRfqSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
     executeStableSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeSynthetix(
+    executeSynthetixSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeUniV3KSElastic(
+    executeUniSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeUniswap(
+    executeUniV3ProMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeVelodrome(
+    executeVelodromeSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
-    executeWrappedstETH(
+    executeWrappedstETHSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
   };
 
-  executeBalV2(
+  executeBalV2Swap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeCamelot(
+  executeCamelotSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeCurve(
+  executeCurveSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeDODO(
+  executeDODOSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeFrax(
+  executeFraxSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeGMX(
+  executeGMXSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeHashflow(
+  executeHashflowSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeKSClassic(
+  executeKyberDMMSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   executeKyberLimitOrder(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
-    overrides?: PayableOverrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  executeMaverick(
-    data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
-    overrides?: PayableOverrides & { from?: string | Promise<string> }
-  ): Promise<ContractTransaction>;
-
-  executePSM(
-    data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executePlatypus(
+  executePSMSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeRfq(
+  executePlatypusSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeStEth(
+  executeRfqSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   executeStableSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeSynthetix(
+  executeSynthetixSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeUniV3KSElastic(
+  executeUniSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeUniswap(
+  executeUniV3ProMMSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeVelodrome(
+  executeVelodromeSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
-  executeWrappedstETH(
+  executeWrappedstETHSwap(
+    index: BigNumberish,
     data: BytesLike,
-    flagsAndPrevAmountOut: BigNumberish,
+    previousAmountOut: BigNumberish,
     overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   callStatic: {
-    executeBalV2(
+    executeBalV2Swap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeCamelot(
+    executeCamelotSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeCurve(
+    executeCurveSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeDODO(
+    executeDODOSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeFrax(
+    executeFraxSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeGMX(
+    executeGMXSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeHashflow(
+    executeHashflowSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeKSClassic(
+    executeKyberDMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
     executeKyberLimitOrder(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeMaverick(
+    executePSMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executePSM(
+    executePlatypusSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executePlatypus(
+    executeRfqSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    executeRfq(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
-    executeStEth(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
     executeStableSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeSynthetix(
+    executeSynthetixSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeUniV3KSElastic(
+    executeUniSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeUniswap(
+    executeUniV3ProMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeVelodrome(
+    executeVelodromeSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    executeWrappedstETH(
+    executeWrappedstETHSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
   };
@@ -597,245 +606,257 @@ export interface IExecutorHelper extends BaseContract {
   filters: {};
 
   estimateGas: {
-    executeBalV2(
+    executeBalV2Swap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeCamelot(
+    executeCamelotSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeCurve(
+    executeCurveSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeDODO(
+    executeDODOSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeFrax(
+    executeFraxSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeGMX(
+    executeGMXSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeHashflow(
+    executeHashflowSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeKSClassic(
+    executeKyberDMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     executeKyberLimitOrder(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
-    executeMaverick(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executePSM(
+    executePSMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executePlatypus(
+    executePlatypusSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeRfq(
+    executeRfqSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<BigNumber>;
-
-    executeStEth(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     executeStableSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeSynthetix(
+    executeSynthetixSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeUniV3KSElastic(
+    executeUniSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeUniswap(
+    executeUniV3ProMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeVelodrome(
+    executeVelodromeSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
-    executeWrappedstETH(
+    executeWrappedstETHSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    executeBalV2(
+    executeBalV2Swap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeCamelot(
+    executeCamelotSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeCurve(
+    executeCurveSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeDODO(
+    executeDODOSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeFrax(
+    executeFraxSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeGMX(
+    executeGMXSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeHashflow(
+    executeHashflowSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeKSClassic(
+    executeKyberDMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     executeKyberLimitOrder(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
-    executeMaverick(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
-      overrides?: PayableOverrides & { from?: string | Promise<string> }
-    ): Promise<PopulatedTransaction>;
-
-    executePSM(
-      data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executePlatypus(
+    executePSMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeRfq(
+    executePlatypusSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeStEth(
+    executeRfqSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     executeStableSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeSynthetix(
+    executeSynthetixSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeUniV3KSElastic(
+    executeUniSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeUniswap(
+    executeUniV3ProMMSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeVelodrome(
+    executeVelodromeSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
-    executeWrappedstETH(
+    executeWrappedstETHSwap(
+      index: BigNumberish,
       data: BytesLike,
-      flagsAndPrevAmountOut: BigNumberish,
+      previousAmountOut: BigNumberish,
       overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
   };