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

package/src/middleware/defaults/feeEstimator.ts

@@ -3,11 +3,30 @@ import { applyUserOpOverrideOrFeeOption } from "../../utils/index.js";
 import type { MiddlewareClient } from "../actions";
 import type { ClientMiddlewareFn } from "../types";
 
-export const defaultFeeEstimator: <C extends MiddlewareClient>(
+/**
+ * Default fee estimator middleware function that estimates the maximum fee per gas and maximum priority fee per gas for a given client and applies the necessary overrides and fee options.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient, defaultFeeEstimator, createBundlerClient } from "@aa-sdk/core";
+ *
+ * const bundlerClient = createBundlerClient(...);
+ *
+ * // NOTE: this is already provided by the smart account client
+ * const client = createSmartAccountClient({
+ *  feeEstimator: defaultFeeEstimator(bundlerClient),
+ *  ...otherParams
+ * });
+ * ```
+ *
+ * @template {MiddlewareClient} C The type of the client
+ * @param {C} client The client to perform the fee estimation
+ * @returns {ClientMiddlewareFn} A middleware function that takes in the struct and options, estimates the fees, and updates the struct with the estimated fees
+ */
+export function defaultFeeEstimator<C extends MiddlewareClient>(
   client: C
-) => ClientMiddlewareFn =
-  (client) =>
-  async (struct, { overrides, feeOptions }) => {
+): ClientMiddlewareFn {
+  return async (struct, { overrides, feeOptions }) => {
     // 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
     //
@@ -48,3 +67,4 @@ export const defaultFeeEstimator: <C extends MiddlewareClient>(
     struct.maxPriorityFeePerGas = maxPriorityFeePerGas;
     return struct;
   };
+}

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/defaults/paymasterAndData.ts

@@ -1,6 +1,14 @@
 import type { UserOperationStruct } from "../../types";
 import type { ClientMiddlewareFn } from "../types";
 
+/**
+ * Middleware function that sets the `paymasterAndData` field in the given struct based on the entry point version of the account.
+ * This is the default used by `createSmartAccountClient` and is not necessary to be used directly.
+ *
+ * @param {UserOperationStruct} struct the user operation structure to be modified
+ * @param {{ account: Account }} context an object containing the account information
+ * @returns {Promise<UserOperationStruct>} a promise that resolves to the modified user operation structure
+ */
 export const defaultPaymasterAndData: ClientMiddlewareFn = async (
   struct,
   { account }

package/src/middleware/defaults/userOpSigner.ts

@@ -8,6 +8,16 @@ import {
 } from "../../utils/index.js";
 import type { ClientMiddlewareFn } from "../types";
 
+/**
+ * Provides a default middleware function for signing user operations with a client account. This function validates the request and adds the signature to it.
+ * This is already included in the client returned from `createSmartAccountClient`
+ *
+ * @param {UserOperationStruct} struct The user operation structure to be signed
+ * @param {*} context The middleware context containing the client and account information
+ * @param {Client} context.client The client object, which should include account and chain information
+ * @param {Account} [context.account] Optional, the account used for signing, defaults to the client's account if not provided
+ * @returns {Promise<UserOperationStruct>} A promise that resolves to the signed user operation structure
+ */
 export const defaultUserOpSigner: ClientMiddlewareFn = async (
   struct,
   { client, account = client.account }

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]
 

package/src/signer/local-account.ts

@@ -11,6 +11,9 @@ import {
 import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
 import type { SmartAccountSigner } from "./types.js";
 
+/**
+ * Represents a local account signer and provides methods to sign messages and transactions, as well as static methods to create the signer from mnemonic or private key.
+ */
 export class LocalAccountSigner<
   T extends HDAccount | PrivateKeyAccount | LocalAccount
 > implements SmartAccountSigner<T>
@@ -18,17 +21,67 @@ export class LocalAccountSigner<
   inner: T;
   signerType: string;
 
+  /**
+   * A function to initialize an object with an inner parameter and derive a signerType from it.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { privateKeyToAccount, generatePrivateKey } from "viem";
+   *
+   * const signer = new LocalAccountSigner(
+   *  privateKeyToAccount(generatePrivateKey()),
+   * );
+   * ```
+   *
+   * @param {T} inner The inner parameter containing the necessary data
+   */
   constructor(inner: T) {
     this.inner = inner;
     this.signerType = inner.type; //  type: "local"
   }
 
+  /**
+   * Signs the provided message using the inner signMessage function.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const signature = await signer.signMessage("Hello, world!");
+   * ```
+   *
+   * @param {string} message The message to be signed
+   * @returns {Promise<any>} A promise that resolves to the signed message
+   */
   readonly signMessage: (message: SignableMessage) => Promise<`0x${string}`> = (
     message
   ) => {
     return this.inner.signMessage({ message });
   };
 
+  /**
+   * Signs typed data using the given parameters.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const signature = await signer.signTypedData({
+   *  domain: {},
+   *  types: {},
+   *  primaryType: "",
+   *  message: {},
+   * });
+   * ```
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} params The parameters defining the typed data and primary type
+   * @returns {Promise<Hex>} A promise that resolves to the signed data in hexadecimal format
+   */
   readonly signTypedData = async <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string = string
@@ -38,10 +91,39 @@ export class LocalAccountSigner<
     return this.inner.signTypedData(params);
   };
 
-  readonly getAddress: () => Promise<`0x${string}`> = async () => {
+  /**
+   * Returns the address of the inner object in a specific hexadecimal format.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const address = await signer.getAddress();
+   * ```
+   *
+   * @returns {Promise<Hex>} A promise that resolves to the address in the format `0x{string}`
+   */
+  readonly getAddress = async (): Promise<`0x${string}`> => {
     return this.inner.address;
   };
 
+  /**
+   * Creates a LocalAccountSigner using the provided mnemonic key and optional HD options.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generateMnemonic } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generateMnemonic());
+   * ```
+   *
+   * @param {string} key The mnemonic key to derive the account from.
+   * @param {HDOptions} [opts] Optional HD options for deriving the account.
+   * @returns {LocalAccountSigner<HDAccount>} A LocalAccountSigner object for the derived account.
+   */
   static mnemonicToAccountSigner(
     key: string,
     opts?: HDOptions
@@ -50,7 +132,20 @@ export class LocalAccountSigner<
     return new LocalAccountSigner(signer);
   }
 
-  static privateKeyToAccountSigner(
+  /**
+   * Creates a `LocalAccountSigner` instance using the provided private key.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * ```
+   *
+   * @param {Hex} key The private key in hexadecimal format
+   * @returns {LocalAccountSigner<PrivateKeyAccount>} An instance of `LocalAccountSigner` initialized with the provided private key
+   */ static privateKeyToAccountSigner(
     key: Hex
   ): LocalAccountSigner<PrivateKeyAccount> {
     const signer = privateKeyToAccount(key);

package/src/signer/schema.ts

@@ -1,6 +1,20 @@
 import { z } from "zod";
 import type { SmartAccountSigner } from "./types";
 
+/**
+ * Checks if the provided object is a `SmartAccountSigner`.
+ *
+ * @example
+ * ```ts
+ * import { isSigner, LocalAccountSigner } from "@aa-sdk/core";
+ *
+ * const signer = new LocalAccountSigner(...);
+ * console.log(isSigner(signer)); // true
+ * ```
+ *
+ * @param {any} signer the object to check
+ * @returns {boolean} A boolean indicating whether the object is a `SmartAccountSigner`
+ */
 export const isSigner = (signer: any): signer is SmartAccountSigner => {
   return (
     signer != null &&

package/src/signer/utils.ts

@@ -5,7 +5,6 @@ import {
   type Address,
   type Hash,
   type Hex,
-  type PublicClient,
 } from "viem";
 
 export type SignWith6492Params = {
@@ -14,13 +13,26 @@ export type SignWith6492Params = {
   signature: Hash;
 };
 
-type VerifyEIP6492SignatureParams = {
-  signer: Address;
-  hash: Hash;
-  signature: Hash;
-  client: PublicClient;
-};
-
+/**
+ * Wraps a given signature with additional data following the EIP-6492 standard.
+ *
+ * @example
+ * ```ts
+ * import { wrapSignatureWith6492 } from "@aa-sdk/core";
+ *
+ * const signature = wrapSignatureWith6492({
+ *  factoryAddress: "0x...",
+ *  factoryCalldata: "0x...",
+ *  signature: "0x...",
+ * });
+ * ```
+ *
+ * @param {SignWith6492Params} params The parameters to wrap the signature
+ * @param {Hex} params.factoryAddress The address of the factory
+ * @param {Hex} params.factoryCalldata The calldata for the factory
+ * @param {Hex} params.signature The original signature that needs to be wrapped
+ * @returns {Hash} The wrapped signature
+ */
 export const wrapSignatureWith6492 = ({
   factoryAddress,
   factoryCalldata,
@@ -42,27 +54,3 @@ export const wrapSignatureWith6492 = ({
     "0x6492649264926492649264926492649264926492649264926492649264926492",
   ]);
 };
-
-// defined in https://github.com/AmbireTech/signature-validator/blob/main/index.ts#L13C17-L13C17
-const universalValidatorByteCode =
-  "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";
-
-export const verifyEIP6492Signature = async ({
-  signer,
-  hash,
-  signature,
-  client,
-}: VerifyEIP6492SignatureParams): Promise<boolean> => {
-  const result = await client.call({
-    data: concat([
-      universalValidatorByteCode,
-      encodeAbiParameters(parseAbiParameters("address, bytes32, bytes"), [
-        signer,
-        hash,
-        signature,
-      ]),
-    ]),
-  });
-
-  return result.data === "0x01";
-};