feat: support one-off percentage overrides for user operations

packages/alchemy/src/middleware/gas-fees.ts

@@ -1,39 +1,42 @@
-import { applyFeeOption, type BigNumberish } from "@alchemy/aa-core";
+import { applyFeeOption, applyUserOperationOverride } from "@alchemy/aa-core";
 import type { AlchemyProvider } from "../provider.js";
 import type { ClientWithAlchemyMethods } from "./client.js";
 
 export const withAlchemyGasFeeEstimator = (
   provider: AlchemyProvider
 ): AlchemyProvider => {
   provider.withFeeDataGetter(async (struct, overrides, feeOptions) => {
-    const maxPriorityFeePerGas =
-      overrides?.maxPriorityFeePerGas != null
-        ? overrides?.maxPriorityFeePerGas
-        : // it's a fair assumption that if someone is using this Alchemy Middleware, then they are using Alchemy RPC
-          applyFeeOption(
-            await (provider.rpcClient as ClientWithAlchemyMethods).request({
-              method: "rundler_maxPriorityFeePerGas",
-              params: [],
-            }),
-            feeOptions?.maxPriorityFeePerGas
-          );
+    let [block, maxPriorityFeePerGasEstimate] = await Promise.all([
+      provider.rpcClient.getBlock({ blockTag: "latest" }),
+      // it's a fair assumption that if someone is using this Alchemy Middleware, then they are using Alchemy RPC
+      (provider.rpcClient as ClientWithAlchemyMethods).request({
+        method: "rundler_maxPriorityFeePerGas",
+        params: [],
+      }),
+    ]);
+    const baseFeePerGas = block.baseFeePerGas;
+    if (baseFeePerGas == null) {
+      throw new Error("baseFeePerGas is null");
+    }
 
-    const estimateMaxFeePerGas = async (priorityFeePerGas: BigNumberish) => {
-      const block = await provider.rpcClient.getBlock({ blockTag: "latest" });
-      const baseFeePerGas = block.baseFeePerGas;
-      if (baseFeePerGas == null) {
-        throw new Error("baseFeePerGas is null");
-      }
-      return applyFeeOption(
-        baseFeePerGas + BigInt(priorityFeePerGas),
-        feeOptions?.maxFeePerGas
+    const maxPriorityFeePerGas =
+      applyUserOperationOverride(
+        maxPriorityFeePerGasEstimate,
+        overrides?.maxPriorityFeePerGas
+      ) ||
+      applyFeeOption(
+        maxPriorityFeePerGasEstimate,
+        feeOptions?.maxPriorityFeePerGas
       );
-    };
-
     const maxFeePerGas =
-      overrides?.maxFeePerGas != null
-        ? overrides?.maxFeePerGas
-        : await estimateMaxFeePerGas(maxPriorityFeePerGas);
+      applyUserOperationOverride(
+        baseFeePerGas + BigInt(maxPriorityFeePerGas),
+        overrides?.maxPriorityFeePerGas
+      ) ||
+      applyFeeOption(
+        baseFeePerGas + BigInt(maxPriorityFeePerGas),
+        feeOptions?.maxPriorityFeePerGas
+      );
 
     return {
       ...struct,

packages/alchemy/src/middleware/gas-manager.ts

@@ -1,6 +1,7 @@
 import {
   deepHexlify,
   filterUndefined,
+  isBigNumberish,
   isPercentage,
   resolveProperties,
   type AccountMiddlewareFn,
@@ -169,15 +170,25 @@ const withAlchemyGasAndPaymasterAndDataMiddleware = <P extends AlchemyProvider>(
     const overrideField = (
       field: keyof UserOperationFeeOptions
     ): Hex | Percentage | undefined => {
-      // one-off absolute override
       if (overrides?.[field] != null) {
-        return deepHexlify(overrides[field]);
+        // one-off absolute override
+        if (isBigNumberish(overrides[field])) {
+          return deepHexlify(overrides[field]);
+        }
+        // one-off percentage overrides
+        else {
+          return {
+            percentage:
+              100 + Number((overrides[field] as Percentage).percentage),
+          };
+        }
       }
 
       // provider level fee options with percentage
       if (isPercentage(feeOptions?.[field])) {
         return {
-          percentage: 100 + Number(feeOptions?.[field]?.percentage),
+          percentage:
+            100 + Number((feeOptions![field] as Percentage).percentage),
         };
       }
 

packages/core/src/index.ts

@@ -50,6 +50,7 @@ export type * from "./utils/index.js";
 export {
   ChainSchema,
   applyFeeOption,
+  applyUserOperationOverride,
   asyncPipe,
   bigIntMax,
   bigIntPercent,

packages/core/src/provider/base.ts

@@ -33,6 +33,7 @@ import {
 } from "../types.js";
 import {
   applyFeeOption,
+  applyUserOperationOverride,
   asyncPipe,
   bigIntMax,
   bigIntPercent,
@@ -521,41 +522,39 @@ export class SmartAccountProvider<
     overrides,
     feeOptions
   ) => {
-    let { callGasLimit, verificationGasLimit, preVerificationGas } =
-      overrides ?? {};
+    const request = deepHexlify(await resolveProperties(struct));
+    const estimates = await this.rpcClient.estimateUserOperationGas(
+      request,
+      this.getEntryPointAddress()
+    );
 
-    if (
-      callGasLimit == null ||
-      verificationGasLimit == null ||
-      preVerificationGas == null
-    ) {
-      const request = deepHexlify(await resolveProperties(struct));
-      const estimates = await this.rpcClient.estimateUserOperationGas(
-        request,
-        this.getEntryPointAddress()
+    const callGasLimit =
+      applyUserOperationOverride(
+        estimates.callGasLimit,
+        overrides?.callGasLimit
+      ) || applyFeeOption(estimates.callGasLimit, feeOptions?.callGasLimit);
+    const verificationGasLimit =
+      applyUserOperationOverride(
+        estimates.verificationGasLimit,
+        overrides?.verificationGasLimit
+      ) ||
+      applyFeeOption(
+        estimates.verificationGasLimit,
+        feeOptions?.verificationGasLimit
+      );
+    const preVerificationGas =
+      applyUserOperationOverride(
+        estimates.preVerificationGas,
+        overrides?.preVerificationGas
+      ) ||
+      applyFeeOption(
+        estimates.preVerificationGas,
+        feeOptions?.preVerificationGas
       );
-
-      callGasLimit =
-        callGasLimit ??
-        applyFeeOption(estimates.callGasLimit, feeOptions?.callGasLimit);
-      verificationGasLimit =
-        verificationGasLimit ??
-        applyFeeOption(
-          estimates.verificationGasLimit,
-          feeOptions?.verificationGasLimit
-        );
-      preVerificationGas =
-        preVerificationGas ??
-        applyFeeOption(
-          estimates.preVerificationGas,
-          feeOptions?.preVerificationGas
-        );
-    }
 
     struct.callGasLimit = callGasLimit;
     struct.verificationGasLimit = verificationGasLimit;
     struct.preVerificationGas = preVerificationGas;
-
     return struct;
   };
 
@@ -564,11 +563,6 @@ export class SmartAccountProvider<
     overrides,
     feeOptions
   ) => {
-    const estimateMaxPriorityFeePerGas = async () => {
-      const estimate = await this.rpcClient.estimateMaxPriorityFeePerGas();
-      return applyFeeOption(estimate, feeOptions?.maxPriorityFeePerGas);
-    };
-
     // maxFeePerGas must be at least the sum of maxPriorityFeePerGas and baseFee
     // so we need to accommodate for the fee option applied maxPriorityFeePerGas for the maxFeePerGas
     //
@@ -577,30 +571,34 @@ export class SmartAccountProvider<
     //
     // Refer to https://docs.alchemy.com/docs/maxpriorityfeepergas-vs-maxfeepergas
     // for more information about maxFeePerGas and maxPriorityFeePerGas
-    const estimateMaxFeePerGas = async (maxPriorityFeePerGas: BigNumberish) => {
-      const feeData = await this.rpcClient.estimateFeesPerGas();
-      if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas) {
-        throw new Error(
-          "feeData is missing maxFeePerGas or maxPriorityFeePerGas"
-        );
-      }
-      const baseFee = applyFeeOption(
-        feeData.maxFeePerGas - feeData.maxPriorityFeePerGas,
-        feeOptions?.maxFeePerGas
-      );
 
-      return BigInt(baseFee) + BigInt(maxPriorityFeePerGas);
-    };
-
-    struct.maxPriorityFeePerGas =
-      overrides?.maxPriorityFeePerGas != null
-        ? overrides?.maxPriorityFeePerGas
-        : await estimateMaxPriorityFeePerGas();
-    struct.maxFeePerGas =
-      overrides?.maxFeePerGas != null
-        ? overrides?.maxFeePerGas
-        : await estimateMaxFeePerGas(struct.maxPriorityFeePerGas);
+    const feeData = await this.rpcClient.estimateFeesPerGas();
+    if (!feeData.maxFeePerGas || !feeData.maxPriorityFeePerGas) {
+      throw new Error(
+        "feeData is missing maxFeePerGas or maxPriorityFeePerGas"
+      );
+    }
 
+    let maxPriorityFeePerGas: BigNumberish =
+      await this.rpcClient.estimateMaxPriorityFeePerGas();
+    maxPriorityFeePerGas =
+      applyUserOperationOverride(
+        maxPriorityFeePerGas,
+        overrides?.maxPriorityFeePerGas
+      ) ||
+      applyFeeOption(maxPriorityFeePerGas, feeOptions?.maxPriorityFeePerGas);
+
+    let maxFeePerGas: BigNumberish =
+      feeData.maxFeePerGas -
+      feeData.maxPriorityFeePerGas +
+      BigInt(maxPriorityFeePerGas);
+
+    maxFeePerGas =
+      applyUserOperationOverride(maxFeePerGas, overrides?.maxFeePerGas) ||
+      applyFeeOption(maxFeePerGas, feeOptions?.maxFeePerGas);
+
+    struct.maxFeePerGas = maxFeePerGas;
+    struct.maxPriorityFeePerGas = maxPriorityFeePerGas;
     return struct;
   };
 

packages/core/src/provider/types.ts

@@ -330,7 +330,6 @@ export interface ISmartAccountProvider<
    * prior to execution.
    *
    * @param override - a function for overriding the default feeDataGetter middleware
-   * @param feeOptions - optional FeeDataFeeOptions to set at the global level of the provider.
    * @returns
    */
   withFeeDataGetter: (override: FeeDataMiddleware) => this;

packages/core/src/types.ts

@@ -43,17 +43,18 @@ export type UserOperationFeeOptions = z.infer<
   typeof UserOperationFeeOptionsSchema
 >;
 
-export type UserOperationOverrides = Partial<
-  Pick<
-    UserOperationStruct,
-    | "callGasLimit"
-    | "maxFeePerGas"
-    | "maxPriorityFeePerGas"
-    | "paymasterAndData"
-    | "preVerificationGas"
-    | "verificationGasLimit"
-  >
->;
+export type UserOperationOverrides = Partial<{
+  callGasLimit: UserOperationStruct["callGasLimit"] | Percentage;
+  maxFeePerGas: UserOperationStruct["maxFeePerGas"] | Percentage;
+  maxPriorityFeePerGas:
+    | UserOperationStruct["maxPriorityFeePerGas"]
+    | Percentage;
+  preVerificationGas: UserOperationStruct["preVerificationGas"] | Percentage;
+  verificationGasLimit:
+    | UserOperationStruct["verificationGasLimit"]
+    | Percentage;
+  paymasterAndData: UserOperationStruct["paymasterAndData"];
+}>;
 
 // represents the request as it needs to be formatted for RPC requests
 export interface UserOperationRequest {

packages/core/src/utils/index.ts

@@ -97,14 +97,33 @@ export function deepHexlify(obj: any): any {
   );
 }
 
+export function applyUserOperationOverride(
+  value: BigNumberish | undefined,
+  override?: BigNumberish | Percentage
+): BigNumberish | undefined {
+  if (override == null) {
+    return value;
+  }
+
+  if (isBigNumberish(override)) {
+    return override;
+  }
+  // percentage override
+  else {
+    return value != null
+      ? bigIntPercent(value, BigInt(100 + override.percentage))
+      : value;
+  }
+}
+
 export function applyFeeOption(
   value: BigNumberish | undefined,
   feeOption?: UserOperationFeeOptionsField
 ): BigNumberish {
   if (feeOption == null) {
     return value ?? 0n;
   }
-  return value
+  return value != null
     ? bigIntClamp(
         feeOption.percentage
           ? bigIntPercent(value, BigInt(100 + feeOption.percentage))
@@ -183,11 +202,11 @@ export function defineReadOnly<T, K extends keyof T>(
 }
 
 export function isBigNumberish(x: any): x is BigNumberish {
-  return BigNumberishSchema.safeParse(x).success;
+  return x != null && BigNumberishSchema.safeParse(x).success;
 }
 
 export function isPercentage(x: any): x is Percentage {
-  return PercentageSchema.safeParse(x).success;
+  return x != null && PercentageSchema.safeParse(x).success;
 }
 
 export function filterUndefined(