@aa-sdk/core 4.0.0-alpha.4 → 4.0.0-alpha.6

package/src/client/decorators/bundlerClient.ts

@@ -55,10 +55,10 @@ export type BundlerActions = {
   /**
    * calls `eth_estimateUserOperationGas` and  returns the result
    *
-   * @param request - the {@link UserOperationRequest} to estimate gas for
+   * @param request - the UserOperationRequest to estimate gas for
    * @param entryPoint - the entry point address the op will be sent to
    * @param stateOverride - the state override to use for the estimation
-   * @returns the gas estimates for the given response (see: {@link UserOperationEstimateGasResponse})
+   * @returns the gas estimates for the given response
    */
   estimateUserOperationGas<
     TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -71,7 +71,7 @@ export type BundlerActions = {
   /**
    * calls `eth_sendUserOperation` and returns the hash of the sent UserOperation
    *
-   * @param request - the {@link UserOperationRequest} to send
+   * @param request - the UserOperationRequest to send
    * @param entryPoint - the entry point address the op will be sent to
    * @returns the hash of the sent UserOperation
    */
@@ -83,25 +83,25 @@ export type BundlerActions = {
   ): Promise<Hash>;
 
   /**
-   * calls `eth_getUserOperationByHash` and returns the {@link UserOperationResponse}
+   * calls `eth_getUserOperationByHash` and returns the UserOperationResponse
    *
    * @param hash - the hash of the UserOperation to fetch
-   * @returns - {@link UserOperationResponse}
+   * @returns - the user operation if found or null
    */
   getUserOperationByHash(hash: Hash): Promise<UserOperationResponse | null>;
 
   /**
-   * calls `eth_getUserOperationReceipt` and returns the {@link UserOperationReceipt}
+   * calls `eth_getUserOperationReceipt` and returns the UserOperationReceipt
    *
    * @param hash - the hash of the UserOperation to get the receipt for
-   * @returns - {@link UserOperationReceipt}
+   * @returns - a user operation receipt or null if not found
    */
   getUserOperationReceipt(hash: Hash): Promise<UserOperationReceipt | null>;
 
   /**
    * calls `eth_supportedEntryPoints` and returns the entry points the RPC supports
    *
-   * @returns - {@link Address}[]
+   * @returns - an array of the entrypoint addresses supported
    */
   getSupportedEntryPoints(): Promise<Address[]>;
 };

package/src/client/isSmartAccountClient.ts

@@ -11,8 +11,8 @@ import type {
  * Useful for narrowing the type of the client down when used within the
  * smart account client decorators
  *
- * @param client a viem client
- * @returns true if the client is a SmartAccountClient
+ * @param {Client<TTransport, TChain, TAccount>} client a viem client
+ * @returns {boolean} true if the client is a SmartAccountClient
  */
 export function isSmartAccountClient<
   TTransport extends Transport = Transport,
@@ -37,8 +37,8 @@ export function isSmartAccountClient<
  * Useful for narrowing the type of the client down when used within the
  * smart account action decorators
  *
- * @param client a viem client
- * @returns true if the account is a BaseSmartAccountClient
+ * @param {Client<TTransport, TChain, TAccount>} client a viem client
+ * @returns {boolean} true if the account is a BaseSmartAccountClient
  */
 export function isBaseSmartAccountClient<
   TTransport extends Transport = Transport,

package/src/client/types.ts

@@ -3,10 +3,7 @@ import type { Hash, Hex } from "viem";
 import type { z } from "zod";
 import type { UserOperationContext } from "../actions/smartAccount/types.js";
 import type { EntryPointVersion } from "../entrypoint/types.js";
-import type {
-  ClientMiddleware,
-  ClientMiddlewareFn,
-} from "../middleware/types.js";
+import type { ClientMiddleware } from "../middleware/types.js";
 import type { UserOperationRequest } from "../types.js";
 import type { ConnectionConfigSchema } from "./schema.js";
 
@@ -37,15 +34,5 @@ export type ClientMiddlewareConfig<
   TContext extends UserOperationContext | undefined =
     | UserOperationContext
     | undefined
-> = Omit<
-  Partial<ClientMiddleware<TContext>>,
-  "dummyPaymasterAndData" | "paymasterAndData"
-> & {
-  paymasterAndData?: {
-    dummyPaymasterAndData: () =>
-      | UserOperationRequest<"0.6.0">["paymasterAndData"]
-      | Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">;
-    paymasterAndData: ClientMiddlewareFn<TContext>;
-  };
-};
+> = Partial<ClientMiddleware<TContext>>;
 // [!endregion ClientMiddlewareConfig]

package/src/errors/account.ts

@@ -9,7 +9,10 @@ export class AccountNotFoundError extends BaseError {
   override name = "AccountNotFoundError";
 
   // TODO: extend this further using docs path as well
-  constructor() {
+
+  /**
+   * Constructor for initializing an error message indicating that an account could not be found to execute the specified action.
+   */ constructor() {
     super("Could not find an Account to execute with this Action.");
   }
 }
@@ -20,6 +23,14 @@ export class AccountNotFoundError extends BaseError {
  */
 export class DefaultFactoryNotDefinedError extends BaseError {
   override name = "DefaultFactoryNotDefinedError";
+
+  /**
+   * Constructs an error message indicating that no default factory was found for the given account type, chain, and entry point version.
+   *
+   * @param {string} accountType the type of account
+   * @param {Chain} chain the blockchain chain
+   * @param {EntryPointVersion} version the entry point version
+   */
   constructor(accountType: string, chain: Chain, version: EntryPointVersion) {
     super(
       [
@@ -35,7 +46,10 @@ export class DefaultFactoryNotDefinedError extends BaseError {
  */
 export class GetCounterFactualAddressError extends BaseError {
   override name = "GetCounterFactualAddressError";
-  constructor() {
+
+  /**
+   * Constructor for initializing an error message indicating the failure of fetching the counter-factual address.
+   */ constructor() {
     super("getCounterFactualAddress failed");
   }
 }
@@ -45,6 +59,12 @@ export class GetCounterFactualAddressError extends BaseError {
  */
 export class UpgradesNotSupportedError extends BaseError {
   override name = "UpgradesNotSupported";
+
+  /**
+   * Error constructor for indicating that upgrades are not supported by the given account type.
+   *
+   * @param {string} accountType The type of account that does not support upgrades
+   */
   constructor(accountType: string) {
     super(`Upgrades are not supported by ${accountType}`);
   }
@@ -55,7 +75,12 @@ export class UpgradesNotSupportedError extends BaseError {
  */
 export class SignTransactionNotSupportedError extends BaseError {
   override name = "SignTransactionNotSupported";
-  constructor() {
+
+  /**
+   * Throws an error indicating that signing a transaction is not supported by smart contracts.
+   *
+   
+   */ constructor() {
     super(`SignTransaction is not supported by smart contracts`);
   }
 }
@@ -65,6 +90,13 @@ export class SignTransactionNotSupportedError extends BaseError {
  */
 export class FailedToGetStorageSlotError extends BaseError {
   override name = "FailedToGetStorageSlotError";
+
+  /**
+   * Custom error message constructor for failing to get a specific storage slot.
+   *
+   * @param {string} slot The storage slot that failed to be accessed or retrieved
+   * @param {string} slotDescriptor A description of the storage slot, for additional context in the error message
+   */
   constructor(slot: string, slotDescriptor: string) {
     super(`Failed to get storage slot ${slot} (${slotDescriptor})`);
   }
@@ -75,6 +107,12 @@ export class FailedToGetStorageSlotError extends BaseError {
  */
 export class BatchExecutionNotSupportedError extends BaseError {
   override name = "BatchExecutionNotSupportedError";
+
+  /**
+   * Constructs an error message indicating that batch execution is not supported by the specified account type.
+   *
+   * @param {string} accountType the type of account that does not support batch execution
+   */
   constructor(accountType: string) {
     super(`Batch execution is not supported by ${accountType}`);
   }
@@ -85,6 +123,12 @@ export class BatchExecutionNotSupportedError extends BaseError {
  */
 export class AccountRequiresOwnerError extends BaseError {
   override name = "AccountRequiresOwnerError";
+
+  /**
+   * Constructs an error indicating that an account of the specified type requires an owner to execute.
+   *
+   * @param {string} accountType The type of account that requires an owner
+   */
   constructor(accountType: string) {
     super(`Account of type ${accountType} requires an owner to execute`);
   }
@@ -95,6 +139,12 @@ export class AccountRequiresOwnerError extends BaseError {
  */
 export class UpgradeToAndCallNotSupportedError extends BaseError {
   override name = "UpgradeToAndCallNotSupportedError";
+
+  /**
+   * Constructs an error message indicating that `UpgradeToAndCall` is not supported by the specified account type.
+   *
+   * @param {string} accountType The type of account that does not support `UpgradeToAndCall`
+   */
   constructor(accountType: string) {
     super(`UpgradeToAndCall is not supported by ${accountType}`);
   }
@@ -105,6 +155,13 @@ export class UpgradeToAndCallNotSupportedError extends BaseError {
  */
 export class IncorrectAccountType extends BaseError {
   override name = "IncorrectAccountTypeError";
+
+  /**
+   * Constructs an error object indicating that the expected account type does not match the actual account type.
+   *
+   * @param {string} expected the expected account type
+   * @param {string} actual the actual account type that was received
+   */
   constructor(expected: string, actual: string) {
     super(`Expected account type ${expected}, got ${actual}`);
   }
@@ -115,7 +172,10 @@ export class IncorrectAccountType extends BaseError {
  */
 export class SmartAccountWithSignerRequiredError extends BaseError {
   override name = "SmartAccountWithSignerRequiredError";
-  constructor() {
+
+  /**
+   * Initializes a new instance of the error class with a predefined error message indicating that a smart account requires a signer.
+   */ constructor() {
     super("Smart account requires a signer");
   }
 }

package/src/errors/client.ts

@@ -6,6 +6,14 @@ import { BaseError } from "./base.js";
  */
 export class IncompatibleClientError extends BaseError {
   override name = "IncompatibleClientError";
+
+  /**
+   * Throws an error when the client type does not match the expected client type.
+   *
+   * @param {string} expectedClient The expected type of the client.
+   * @param {string} method The method that was called.
+   * @param {Client} client The client instance.
+   */
   constructor(expectedClient: string, method: string, client: Client) {
     super(
       [
@@ -21,6 +29,12 @@ export class IncompatibleClientError extends BaseError {
  */
 export class InvalidRpcUrlError extends BaseError {
   override name = "InvalidRpcUrlError";
+
+  /**
+   * Creates an instance of an error with a message indicating an invalid RPC URL.
+   *
+   * @param {string} [rpcUrl] The invalid RPC URL that caused the error
+   */
   constructor(rpcUrl?: string) {
     super(`Invalid RPC URL ${rpcUrl}`);
   }
@@ -31,6 +45,10 @@ export class InvalidRpcUrlError extends BaseError {
  */
 export class ChainNotFoundError extends BaseError {
   override name = "ChainNotFoundError";
+
+  /**
+   * Initializes a new instance of the error message with a default message indicating that no chain was supplied to the client.
+   */
   constructor() {
     super("No chain supplied to the client");
   }

package/src/errors/entrypoint.ts

@@ -7,6 +7,12 @@ import { BaseError } from "./base.js";
 export class EntryPointNotFoundError extends BaseError {
   override name = "EntryPointNotFoundError";
 
+  /**
+   * Constructs an error message indicating that no default entry point exists for the given chain and entry point version.
+   *
+   * @param {Chain} chain The blockchain network for which the entry point is being queried
+   * @param {any} entryPointVersion The version of the entry point for which no default exists
+   */
   constructor(chain: Chain, entryPointVersion: any) {
     super(
       [
@@ -23,6 +29,12 @@ export class EntryPointNotFoundError extends BaseError {
 export class InvalidEntryPointError extends BaseError {
   override name = "InvalidEntryPointError";
 
+  /**
+   * Constructs an error indicating an invalid entry point version for a specific chain.
+   *
+   * @param {Chain} chain The chain object containing information about the blockchain
+   * @param {any} entryPointVersion The entry point version that is invalid
+   */
   constructor(chain: Chain, entryPointVersion: any) {
     super(
       `Invalid entry point: unexpected version ${entryPointVersion} for ${chain.name}.`

package/src/errors/signer.ts

@@ -5,6 +5,12 @@ import { BaseError } from "./base.js";
  */
 export class InvalidSignerTypeError extends BaseError {
   override name = "InvalidSignerTypeError";
+
+  /**
+   * Constructs an error message when an invalid signer type is passed to SmartAccountSigner.
+   *
+   * @param {string} [signerType] An optional parameter specifying the signer type. If not provided, a default error message will be used.
+   */
   constructor(signerType?: string) {
     super(
       [

package/src/errors/transaction.ts

@@ -6,7 +6,10 @@ import { BaseError } from "./base.js";
  */
 export class TransactionMissingToParamError extends BaseError {
   override name = "TransactionMissingToParamError";
-  constructor() {
+
+  /**
+   * Throws an error indicating that a transaction is missing the `to` address in the request.
+   */ constructor() {
     super("Transaction is missing `to` address set on request");
   }
 }
@@ -16,6 +19,12 @@ export class TransactionMissingToParamError extends BaseError {
  */
 export class FailedToFindTransactionError extends BaseError {
   override name = "FailedToFindTransactionError";
+
+  /**
+   * Constructs a new error message indicating a failure to find the transaction for the specified user operation hash.
+   *
+   * @param {Hex} hash The hexadecimal value representing the user operation hash.
+   */
   constructor(hash: Hex) {
     super(`Failed to find transaction for user operation ${hash}`);
   }

package/src/errors/useroperation.ts

@@ -1,10 +1,9 @@
 import type { UserOperationRequest, UserOperationStruct } from "../types.js";
 import { BaseError } from "./base.js";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { dropAndReplaceUserOperation } from "../actions/smartAccount/dropAndReplaceUserOperation.js";
 
 /**
- * Thrown when a {@link UserOperationStruct} is not a valid request
+ * Thrown when a UserOperationStruct is not a valid request
  *
  * extends viem BaseError
  */
@@ -18,7 +17,7 @@ export class InvalidUserOperationError extends BaseError {
    *
    * InvalidUserOperationError constructor
    *
-   * @param uo the invalid user operation struct
+   * @param {UserOperationStruct} uo the invalid user operation struct
    */
   constructor(uo: UserOperationStruct) {
     super(
@@ -41,12 +40,12 @@ export class InvalidUserOperationError extends BaseError {
  * Error thrown when waiting for user operation request to be mined.
  *
  * Includes the internal error as well as the request that failed. This request
- * can then be used with {@link dropAndReplaceUserOperation} to retry the operation.
+ * can then be used with dropAndReplaceUserOperation to retry the operation.
  */
 export class WaitForUserOperationError extends BaseError {
   /**
-   * @param request the user operation request that failed
-   * @param error the underlying error that caused the failure
+   * @param {UserOperationRequest} request the user operation request that failed
+   * @param {Error} error the underlying error that caused the failure
    */
   constructor(public request: UserOperationRequest, error: Error) {
     super(`Failed to find User Operation: ${error.message}`);

package/src/index.ts

@@ -7,9 +7,6 @@ export { EntryPointAbi_v7 } from "./abis/EntryPointAbi_v7.js";
 export { SimpleAccountAbi_v6 } from "./abis/SimpleAccountAbi_v6.js";
 export { SimpleAccountAbi_v7 } from "./abis/SimpleAccountAbi_v7.js";
 export { SimpleAccountFactoryAbi } from "./abis/SimpleAccountFactoryAbi.js";
-export { BaseSmartContractAccount } from "./account/base.js";
-export { createSimpleSmartAccount } from "./account/simple.js";
-export type { SimpleSmartAccount } from "./account/simple.js";
 export type * from "./account/smartContractAccount.js";
 export {
   getAccountAddress,
@@ -17,10 +14,6 @@ export {
   parseFactoryAddressFromAccountInitCode,
   toSmartContractAccount,
 } from "./account/smartContractAccount.js";
-export type {
-  BaseSmartAccountParams,
-  SignTypedDataParams,
-} from "./account/types.js";
 export { buildUserOperation } from "./actions/smartAccount/buildUserOperation.js";
 export { buildUserOperationFromTx } from "./actions/smartAccount/buildUserOperationFromTx.js";
 export { buildUserOperationFromTxs } from "./actions/smartAccount/buildUserOperationFromTxs.js";
@@ -101,6 +94,8 @@ export { defaultFeeEstimator } from "./middleware/defaults/feeEstimator.js";
 export { defaultGasEstimator } from "./middleware/defaults/gasEstimator.js";
 export { defaultPaymasterAndData } from "./middleware/defaults/paymasterAndData.js";
 export { defaultUserOpSigner } from "./middleware/defaults/userOpSigner.js";
+export type * from "./middleware/erc7677middleware.js";
+export { erc7677Middleware } from "./middleware/erc7677middleware.js";
 export { noopMiddleware } from "./middleware/noopMiddleware.js";
 export type * from "./middleware/types.js";
 export { LocalAccountSigner } from "./signer/local-account.js";
@@ -132,7 +127,6 @@ export {
   concatPaymasterAndData,
   deepHexlify,
   filterUndefined,
-  getDefaultSimpleAccountFactoryAddress,
   getDefaultUserOperationFeeOptions,
   isBigNumberish,
   isMultiplier,

package/src/logger.ts

@@ -14,38 +14,126 @@ export class Logger {
   static logLevel: LogLevel = LogLevel.INFO;
   static logFilter?: string;
 
+  /**
+   * Sets the log level for logging purposes.
+   *
+   * @example
+   * ```ts
+   * import { Logger, LogLevel } from "@aa-sdk/core";
+   * Logger.setLogLevel(LogLevel.DEBUG);
+   * ```
+   *
+   * @param {LogLevel} logLevel The desired log level
+   */
   static setLogLevel(logLevel: LogLevel) {
     this.logLevel = logLevel;
   }
 
+  /**
+   * Sets the log filter pattern.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.setLogFilter("error");
+   * ```
+   *
+   * @param {string} pattern The pattern to set as the log filter
+   */
   static setLogFilter(pattern: string) {
     this.logFilter = pattern;
   }
 
+  /**
+   * Logs an error message to the console if the logging condition is met.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.error("An error occurred while processing the request");
+   * ```
+   *
+   * @param {string} msg The primary error message to be logged
+   * @param {...any[]} args Additional arguments to be logged along with the error message
+   */
   static error(msg: string, ...args: any[]) {
     if (!this.shouldLog(msg, LogLevel.ERROR)) return;
 
     console.error(msg, ...args);
   }
 
+  /**
+   * Logs a warning message if the logging conditions are met.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.warn("Careful...");
+   * ```
+   *
+   * @param {string} msg The message to log as a warning
+   * @param {...any[]} args Additional parameters to log along with the message
+   */
   static warn(msg: string, ...args: any[]) {
     if (!this.shouldLog(msg, LogLevel.WARN)) return;
 
     console.warn(msg, ...args);
   }
 
+  /**
+   * Logs a debug message to the console if the log level allows it.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.debug("Something is happening");
+   * ```
+   *
+   * @param {string} msg The message to log
+   * @param {...any[]} args Additional arguments to pass to the console.debug method
+   */
   static debug(msg: string, ...args: any[]) {
     if (!this.shouldLog(msg, LogLevel.DEBUG)) return;
 
     console.debug(msg, ...args);
   }
 
+  /**
+   * Logs an informational message to the console if the logging level is set to INFO.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.info("Something is happening");
+   * ```
+   *
+   * @param {string} msg the message to log
+   * @param {...any[]} args additional arguments to log alongside the message
+   */
   static info(msg: string, ...args: any[]) {
     if (!this.shouldLog(msg, LogLevel.INFO)) return;
 
     console.info(msg, ...args);
   }
 
+  /**
+   * Logs a message with additional arguments if the logging level permits it.
+   *
+   * @example
+   * ```ts
+   * import { Logger } from "@aa-sdk/core";
+   *
+   * Logger.verbose("Something is happening");
+   * ```
+   *
+   * @param {string} msg The message to log
+   * @param {...any[]} args Additional arguments to be logged
+   */
   static verbose(msg: string, ...args: any[]) {
     if (!this.shouldLog(msg, LogLevel.VERBOSE)) return;
 

package/src/middleware/actions.ts

@@ -1,5 +1,4 @@
 import {
-  isHex,
   type Chain,
   type Client,
   type PublicActions,
@@ -12,10 +11,6 @@ import type {
   BundlerRpcSchema,
 } from "../client/decorators/bundlerClient.js";
 import type { ClientMiddlewareConfig } from "../client/types.js";
-import {
-  concatPaymasterAndData,
-  parsePaymasterAndData,
-} from "../utils/userop.js";
 import { defaultFeeEstimator } from "./defaults/feeEstimator.js";
 import { defaultGasEstimator } from "./defaults/gasEstimator.js";
 import { defaultPaymasterAndData } from "./defaults/paymasterAndData.js";
@@ -45,11 +40,11 @@ export type MiddlewareClient<
 >;
 
 /**
- * export function that takes in {@link ClientMiddlewareConfig} used during client initiation
+ * function that takes in ClientMiddlewareConfig used during client initiation
  * and returns the middleware actions object that the smart account client extends with
  *
- * @param overrides - {@link ClientMiddlewareConfig} used during client initiation for overriding default middlewares
- * @returns middleware actions object
+ * @param {ClientMiddlewareConfig} overrides config used during client initiation for overriding default middlewares
+ * @returns {(client: MiddlewareClient<TTransport, TChain, TAccount>) => { middleware: ClientMiddleware }} middleware actions object
  */
 export const middlewareActions =
   (overrides: ClientMiddlewareConfig) =>
@@ -64,27 +59,11 @@ export const middlewareActions =
   ): { middleware: ClientMiddleware } => ({
     middleware: {
       customMiddleware: overrides.customMiddleware ?? noopMiddleware,
-      dummyPaymasterAndData: overrides.paymasterAndData?.dummyPaymasterAndData
-        ? async (struct, { account }) => {
-            const data = overrides.paymasterAndData!.dummyPaymasterAndData();
-            const paymasterOverrides =
-              account.getEntryPoint().version === "0.7.0"
-                ? isHex(data)
-                  ? parsePaymasterAndData(data)
-                  : data
-                : {
-                    paymasterAndData: isHex(data)
-                      ? data
-                      : concatPaymasterAndData(data),
-                  };
-            return { ...struct, ...paymasterOverrides };
-          }
-        : defaultPaymasterAndData,
-
+      dummyPaymasterAndData:
+        overrides.dummyPaymasterAndData ?? defaultPaymasterAndData,
       feeEstimator: overrides.feeEstimator ?? defaultFeeEstimator(client),
       gasEstimator: overrides.gasEstimator ?? defaultGasEstimator(client),
-      paymasterAndData:
-        overrides.paymasterAndData?.paymasterAndData ?? defaultPaymasterAndData,
+      paymasterAndData: overrides.paymasterAndData ?? defaultPaymasterAndData,
       userOperationSimulator:
         overrides.userOperationSimulator ?? noopMiddleware,
       signUserOperation: overrides.signUserOperation ?? defaultUserOpSigner,

package/src/middleware/defaults/gasEstimator.ts

@@ -13,13 +13,13 @@ import type { ClientMiddlewareFn } from "../types.js";
  * You can override this middleware with your custom gas estimator middleware
  * by passing it to the client constructor
  *
- * @param client smart account client instance to apply the middleware to
- * @returns middleware execution function used to estimate gas for user operations
+ * @param {MiddlewareClient} client smart account client instance to apply the middleware to
+ * @returns {ClientMiddlewareFn} middleware execution function used to estimate gas for user operations
  */
 export const defaultGasEstimator: <C extends MiddlewareClient>(
   client: C
 ) => ClientMiddlewareFn =
-  (client) =>
+  (client: MiddlewareClient): ClientMiddlewareFn =>
   async (struct, { account, overrides, feeOptions }) => {
     const request = deepHexlify(await resolveProperties(struct));
 
@@ -58,8 +58,11 @@ export const defaultGasEstimator: <C extends MiddlewareClient>(
         (feeOptions as UserOperationFeeOptions<"0.7.0">)
           ?.paymasterVerificationGasLimit
       );
-      (struct as UserOperationStruct<"0.7.0">).paymasterVerificationGasLimit =
-        paymasterVerificationGasLimit;
+      const uo_v7 = struct as UserOperationStruct<"0.7.0">;
+
+      uo_v7.paymasterVerificationGasLimit = paymasterVerificationGasLimit;
+
+      uo_v7.paymasterPostOpGasLimit = uo_v7.paymasterPostOpGasLimit ?? "0x0";
     }
 
     return struct;