@aa-sdk/core 4.0.0-alpha.1 → 4.0.0-alpha.10

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";
@@ -31,27 +24,6 @@ export { sendTransactions } from "./actions/smartAccount/sendTransactions.js";
 export { sendUserOperation } from "./actions/smartAccount/sendUserOperation.js";
 export type * from "./actions/smartAccount/types.js";
 export { waitForUserOperationTransaction } from "./actions/smartAccount/waitForUserOperationTransacation.js";
-export {
-  arbitrum,
-  arbitrumGoerli,
-  arbitrumSepolia,
-  base,
-  baseGoerli,
-  baseSepolia,
-  fraxtal,
-  fraxtalSepolia,
-  goerli,
-  mainnet,
-  optimism,
-  optimismGoerli,
-  optimismSepolia,
-  polygon,
-  polygonAmoy,
-  polygonMumbai,
-  sepolia,
-  zora,
-  zoraSepolia,
-} from "./chains/index.js";
 export type * from "./client/bundlerClient.js";
 export {
   createBundlerClient,
@@ -122,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";
@@ -136,7 +110,6 @@ export { split, type SplitTransportParams } from "./transport/split.js";
 export type * from "./types.js";
 export type * from "./utils/index.js";
 export {
-  AlchemyChainMap,
   BigNumberishRangeSchema,
   BigNumberishSchema,
   ChainSchema,
@@ -154,8 +127,6 @@ export {
   concatPaymasterAndData,
   deepHexlify,
   filterUndefined,
-  getChain,
-  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,12 @@ 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 ?? (uo_v7.paymaster ? "0x0" : undefined);
     }
 
     return struct;

package/src/middleware/erc7677middleware.ts

@@ -0,0 +1,201 @@
+import {
+  toHex,
+  type Address,
+  type Chain,
+  type Client,
+  type Hex,
+  type Transport,
+} from "viem";
+import type { ClientMiddlewareConfig } from "../client/types";
+import type { EntryPointVersion } from "../entrypoint/types";
+import { ChainNotFoundError } from "../errors/client.js";
+import type {
+  UserOperationFeeOptions,
+  UserOperationOverrides,
+  UserOperationRequest,
+  UserOperationStruct,
+} from "../types";
+import {
+  deepHexlify,
+  resolveProperties,
+  type Deferrable,
+} from "../utils/index.js";
+import type { ClientMiddlewareFn } from "./types";
+
+export type Erc7677RpcSchema = [
+  {
+    Method: "pm_getPaymasterStubData";
+    Parameters: [UserOperationRequest, Address, Hex, Record<string, any>];
+    ReturnType: {
+      sponsor?: { name: string; icon?: string }; // Sponsor info
+      paymaster?: Address; // Paymaster address (entrypoint v0.7)
+      paymasterData?: Hex; // Paymaster data (entrypoint v0.7)
+      paymasterVerificationGasLimit?: Hex; // Paymaster validation gas (entrypoint v0.7)
+      paymasterPostOpGasLimit?: Hex; // Paymaster post-op gas (entrypoint v0.7)
+      paymasterAndData?: Hex; // Paymaster and data (entrypoint v0.6)
+      isFinal?: boolean; // Indicates that the caller does not need to call pm_getPaymasterData
+    };
+  },
+  {
+    Method: "pm_getPaymasterData";
+    Parameters: [UserOperationRequest, Address, Hex, Record<string, any>];
+    ReturnType: {
+      paymaster?: Address; // Paymaster address (entrypoint v0.7)
+      paymasterData?: Hex; // Paymaster data (entrypoint v0.7)
+      paymasterAndData?: Hex; // Paymaster and data (entrypoint v0.6)
+    };
+  }
+];
+
+export type Erc7677Client<T extends Transport = Transport> = Client<
+  T,
+  Chain,
+  undefined,
+  Erc7677RpcSchema
+>;
+
+export type Erc7677MiddlewareParams<
+  TContext extends Record<string, any> | undefined =
+    | Record<string, any>
+    | undefined,
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = {
+  context?:
+    | ((
+        struct: Deferrable<UserOperationStruct<TEntryPointVersion>>,
+        args: {
+          overrides?: UserOperationOverrides<TEntryPointVersion>;
+          feeOptions?: UserOperationFeeOptions;
+        }
+      ) => Promise<TContext>)
+    | TContext;
+};
+
+/**
+ * Middleware function for interacting with ERC-7677 enabled clients. It supports resolving paymaster and data fields for user operations.
+ * This middleware assumes that your RPC provider supports the ERC-7677 methods (pm_getPaymasterStubData and pm_getPaymasterData).
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient, erc7677Middleware } from "@aa-sdk/core";
+ * import { http } from "viem";
+ * import { sepolia } from "viem/chains";
+ *
+ * const client = createSmartAccountClient({
+ *  transport: http("rpc-url"),
+ *  chain: sepolia,
+ *  // this assumes that your RPC provider supports the ERC-7677 methods AND takes no context
+ *  ...erc7677Middleware(),
+ * })
+ * ```
+ *
+ * @param {Erc7677MiddlewareParams<TContext>} params Middleware parameters including context function or object. Context can be resolved dynamically by passing in a function which takes in the context at the time of sending a user op
+ * @returns {Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData">} An object containing middleware functions `dummyPaymasterAndData` and `paymasterAndData` for processing user operations with the paymaster data
+ */
+export function erc7677Middleware<
+  TContext extends Record<string, any> | undefined =
+    | Record<string, any>
+    | undefined
+>(
+  params?: Erc7677MiddlewareParams<TContext>
+): Pick<ClientMiddlewareConfig, "dummyPaymasterAndData" | "paymasterAndData"> {
+  const dummyPaymasterAndData: ClientMiddlewareFn = async (
+    uo,
+    { client, account, feeOptions, overrides }
+  ) => {
+    const userOp = deepHexlify(await resolveProperties(uo));
+
+    // Those values will be set after fee estimation.
+    userOp.maxFeePerGas = "0x0";
+    userOp.maxPriorityFeePerGas = "0x0";
+    userOp.callGasLimit = "0x0";
+    userOp.verificationGasLimit = "0x0";
+    userOp.preVerificationGas = "0x0";
+
+    const entrypoint = account.getEntryPoint();
+
+    if (entrypoint.version === "0.7.0") {
+      userOp.paymasterVerificationGasLimit = "0x0";
+      userOp.paymasterPostOpGasLimit = "0x0";
+    }
+
+    const context =
+      (typeof params?.context === "function"
+        ? await params?.context(userOp, { overrides, feeOptions })
+        : params?.context) ?? {};
+
+    if (!client.chain) {
+      throw new ChainNotFoundError();
+    }
+
+    const erc7677client = client as Erc7677Client;
+    // TODO: probably need to handle the sponsor and isFinal fields
+    const {
+      paymaster,
+      paymasterAndData,
+      paymasterData,
+      paymasterPostOpGasLimit,
+      paymasterVerificationGasLimit,
+    } = await erc7677client.request({
+      method: "pm_getPaymasterStubData",
+      params: [userOp, entrypoint.address, toHex(client.chain.id), context],
+    });
+
+    if (entrypoint.version === "0.6.0") {
+      return {
+        ...uo,
+        paymasterAndData,
+      };
+    }
+
+    return {
+      ...uo,
+      paymaster,
+      paymasterData,
+      paymasterPostOpGasLimit,
+      paymasterVerificationGasLimit,
+    };
+  };
+
+  const paymasterAndData: ClientMiddlewareFn = async (
+    uo,
+    { client, account, feeOptions, overrides }
+  ) => {
+    const userOp = deepHexlify(await resolveProperties(uo));
+    const context =
+      (typeof params?.context === "function"
+        ? await params?.context(userOp, { overrides, feeOptions })
+        : params?.context) ?? {};
+
+    if (!client.chain) {
+      throw new ChainNotFoundError();
+    }
+
+    const erc7677client = client as Erc7677Client;
+
+    const entrypoint = account.getEntryPoint();
+    const { paymaster, paymasterAndData, paymasterData } =
+      await erc7677client.request({
+        method: "pm_getPaymasterData",
+        params: [userOp, entrypoint.address, toHex(client.chain.id), context],
+      });
+
+    if (entrypoint.version === "0.6.0") {
+      return {
+        ...uo,
+        paymasterAndData,
+      };
+    }
+
+    return {
+      ...uo,
+      paymaster,
+      paymasterData,
+    };
+  };
+
+  return {
+    dummyPaymasterAndData,
+    paymasterAndData,
+  };
+}

package/src/middleware/noopMiddleware.ts

@@ -1,12 +1,14 @@
+import type { UserOperationContext } from "../actions/smartAccount/types";
 import type { ClientMiddlewareFn } from "./types";
 
 /**
  * Noop middleware that does nothing and passes the arguments through
  *
- * @async
- * @param args the client middleware arguments passed to the middleware
- * @returns the arguments passed to the middleware and returned as is without modification
+ * @param {Deferrable<UserOperationStruct<TEntryPointVersion>>} args the client middleware arguments passed to the middleware
+ * @returns {Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>} the arguments passed to the middleware and returned as is without modification
  */
-export const noopMiddleware: ClientMiddlewareFn = async (args) => {
+export const noopMiddleware: ClientMiddlewareFn<
+  UserOperationContext | undefined
+> = async (args) => {
   return args;
 };

package/src/middleware/types.ts

@@ -11,6 +11,21 @@ import type {
 import type { Deferrable } from "../utils";
 import type { MiddlewareClient } from "./actions";
 
+export type ClientMiddlewareArgs<
+  TAccount extends SmartContractAccount,
+  C extends MiddlewareClient,
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+> = {
+  overrides?: UserOperationOverrides<TEntryPointVersion>;
+  context?: TContext;
+  feeOptions?: UserOperationFeeOptions;
+  account: TAccount;
+  client: C;
+};
+
 // [!region ClientMiddlewareFn]
 export type ClientMiddlewareFn<
   TContext extends UserOperationContext | undefined =
@@ -22,13 +37,7 @@ export type ClientMiddlewareFn<
   TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
 >(
   struct: Deferrable<UserOperationStruct<TEntryPointVersion>>,
-  args: {
-    overrides?: UserOperationOverrides<TEntryPointVersion>;
-    context?: TContext;
-    feeOptions?: UserOperationFeeOptions;
-    account: TAccount;
-    client: C;
-  }
+  args: ClientMiddlewareArgs<TAccount, C, TContext, TEntryPointVersion>
 ) => Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>;
 // [!endregion ClientMiddlewareFn]