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

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

@@ -21,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
@@ -41,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
@@ -53,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/wallet-client.ts

@@ -16,6 +16,27 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
   signerType: string;
   inner: WalletClient;
 
+  /**
+   * Initializes a signer with a given wallet client and signer type.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * ```
+   *
+   * @param {WalletClient} client The wallet client to interact with
+   * @param {string} signerType The type of signer; must be a valid signer type, otherwise an error will be thrown
+   * @throws {InvalidSignerTypeError} If the signer type is invalid
+   */
   constructor(client: WalletClient, signerType: string) {
     this.inner = client;
     if (!signerType) {
@@ -24,11 +45,52 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
     this.signerType = signerType;
   }
 
+  /**
+   * Asynchronously retrieves addresses from the inner object and returns the first address after applying the `getAddress` function.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.getAddress());
+   * ```
+   *
+   * @returns {Promise<string>} A promise that resolves to the first address after being processed by the `getAddress` function.
+   */
   getAddress: () => Promise<`0x${string}`> = async () => {
     let addresses = await this.inner.getAddresses();
     return getAddress(addresses[0]);
   };
 
+  /**
+   * Signs a message using the account's signing method.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.signMessage("hello"));
+   * ```
+   *
+   * @param {string} message the message string that needs to be signed
+   * @returns {Promise<string>} a promise that resolves to the signed message
+   */
   readonly signMessage: (message: SignableMessage) => Promise<`0x${string}`> =
     async (message) => {
       const account = this.inner.account ?? (await this.getAddress());
@@ -36,6 +98,33 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
       return this.inner.signMessage({ message, account });
     };
 
+  /**
+   * Signs the provided typed data using the account's private key.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.signTypedData({
+   *  types: {
+   *    "Message": [{ name: "content", type: "string" }]
+   *  },
+   *  primaryType: "Message",
+   *  message: { content: "Hello" },
+   * }));
+   * ```
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} typedData The typed data to be signed
+   * @returns {Promise<Hex>} A promise that resolves to a hex string representing the signed data
+   */
   signTypedData = async <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string = string

package/src/transport/split.ts

@@ -37,8 +37,8 @@ export interface SplitTransportParams {
  * });
  * ```
  *
- * @param params {@link SplitTransportParams} split transport configuration containing the methods overrides and fallback transport
- * @returns a {@link CustomTransport} that splits traffic
+ * @param {SplitTransportParams} params split transport configuration containing the methods overrides and fallback transport
+ * @returns {CustomTransport} a viem Transport that splits traffic
  */
 export const split = (params: SplitTransportParams): CustomTransport => {
   const overrideMap = params.overrides.reduce((accum, curr) => {

package/src/utils/bigint.ts

@@ -5,8 +5,8 @@ import { isMultiplier } from "./schema.js";
 /**
  * Returns the max bigint in a list of bigints
  *
- * @param args a list of bigints to get the max of
- * @returns the max bigint in the list
+ * @param {bigint[]} args a list of bigints to get the max of
+ * @returns {bigint} the max bigint in the list
  */
 export const bigIntMax = (...args: bigint[]): bigint => {
   if (!args.length) {
@@ -19,8 +19,8 @@ export const bigIntMax = (...args: bigint[]): bigint => {
 /**
  * Returns the min bigint in a list of bigints
  *
- * @param args a list of bigints to get the max of
- * @returns the min bigint in the list
+ * @param {bigint[]} args a list of bigints to get the max of
+ * @returns {bigint} the min bigint in the list
  */
 export const bigIntMin = (...args: bigint[]): bigint => {
   if (!args.length) {
@@ -33,16 +33,16 @@ export const bigIntMin = (...args: bigint[]): bigint => {
 /**
  * Given a bigint and a min-max range, returns the min-max clamped bigint value
  *
- * @param value a bigint value to clamp
- * @param lower lower bound min max tuple value
- * @param upper upper bound min max tuple value
- * @returns the clamped bigint value per given range
+ * @param {BigNumberish} value a bigint value to clamp
+ * @param {BigNumberish | undefined} lower lower bound min max tuple value
+ * @param {BigNumberish | undefined} upper upper bound min max tuple value
+ * @returns {bigint} the clamped bigint value per given range
  */
 export const bigIntClamp = (
   value: BigNumberish,
   lower: BigNumberish | null | undefined,
   upper: BigNumberish | null | undefined
-) => {
+): bigint => {
   lower = lower != null ? BigInt(lower) : null;
   upper = upper != null ? BigInt(upper) : null;
 
@@ -71,10 +71,10 @@ export enum RoundingMode {
  * Given a bigint and a number (which can be a float), returns the bigint value.
  * Note: this function has loss and will round down to the nearest integer.
  *
- * @param base - the number to be multiplied
- * @param multiplier - the amount to multiply by
- * @param roundingMode - the rounding mode to use when calculating the percent. defaults to ROUND_UP
- * @returns the bigint value of the multiplication with the number rounded by the rounding mode
+ * @param {BigNumberish} base - the number to be multiplied
+ * @param {number} multiplier - the amount to multiply by
+ * @param {RoundingMode} roundingMode - the rounding mode to use when calculating the percent. defaults to ROUND_UP
+ * @returns {bigint} the bigint value of the multiplication with the number rounded by the rounding mode
  */
 export const bigIntMultiply = (
   base: BigNumberish,
@@ -111,8 +111,8 @@ export const bigIntMultiply = (
  * });
  * ```
  *
- * @param phrase -- any string value.
- * @returns the bigint value of the hashed string
+ * @param {string} phrase -- any string value.
+ * @returns {bigint} the bigint value of the hashed string
  */
 export const stringToIndex = (phrase: string): bigint =>
   BigInt(keccak256(toHex(phrase)));

package/src/utils/bytes.ts

@@ -8,11 +8,11 @@ type TakeBytesOpts = {
 /**
  * Given a bytes string, returns a slice of the bytes
  *
- * @param bytes - the hex string representing bytes
- * @param opts - optional parameters for slicing the bytes
- * @param opts.offset - the offset in bytes to start slicing from
- * @param opts.count - the number of bytes to slice
- * @returns the sliced bytes
+ * @param {Hex} bytes - the hex string representing bytes
+ * @param {TakeBytesOpts} opts - optional parameters for slicing the bytes
+ * @param {number} opts.offset - the offset in bytes to start slicing from
+ * @param {number} opts.count - the number of bytes to slice
+ * @returns {Hex} the sliced bytes
  */
 export const takeBytes = (bytes: Hex, opts: TakeBytesOpts = {}): Hex => {
   const { offset, count } = opts;

package/src/utils/defaults.ts

@@ -1,79 +1,7 @@
-import { type Address, type Chain } from "viem";
-import {
-  arbitrum,
-  arbitrumGoerli,
-  arbitrumSepolia,
-  base,
-  baseGoerli,
-  baseSepolia,
-  fraxtal,
-  goerli,
-  mainnet,
-  optimism,
-  optimismGoerli,
-  optimismSepolia,
-  polygon,
-  polygonAmoy,
-  polygonMumbai,
-  sepolia,
-  zora,
-  zoraSepolia,
-} from "viem/chains";
-import { defaultEntryPointVersion } from "../entrypoint/index.js";
-import type { EntryPointVersion } from "../entrypoint/types.js";
-import { DefaultFactoryNotDefinedError } from "../errors/account.js";
+import { type Chain } from "viem";
+import { arbitrum, arbitrumGoerli, arbitrumSepolia } from "viem/chains";
 import type { UserOperationFeeOptions } from "../types.js";
 
-/**
- * Utility method returning the default simple account factory address given a {@link Chain} object
- *
- * @param chain - a {@link Chain} object
- * @param version - {@link EntryPointVersion} value that defaults to `defaultEntryPointVersion`
- * @returns a {@link abi.Address} for the given chain
- * @throws if the chain doesn't have an address currently deployed
- */
-export const getDefaultSimpleAccountFactoryAddress = (
-  chain: Chain,
-  version: EntryPointVersion = defaultEntryPointVersion
-): Address => {
-  switch (version) {
-    case "0.6.0":
-      switch (chain.id) {
-        case mainnet.id:
-        case polygon.id:
-        case polygonAmoy.id:
-        case optimism.id:
-        case optimismSepolia.id:
-        case arbitrum.id:
-        case arbitrumSepolia.id:
-        case base.id:
-        case baseGoerli.id:
-        case baseSepolia.id:
-        case fraxtal.id:
-        case 2523:
-        case zora.id:
-        case zoraSepolia.id:
-          return "0x15Ba39375ee2Ab563E8873C8390be6f2E2F50232";
-        case sepolia.id:
-        case goerli.id:
-        case polygonMumbai.id:
-        case optimismGoerli.id:
-        case arbitrumGoerli.id:
-          return "0x9406Cc6185a346906296840746125a0E44976454";
-        default:
-          break;
-      }
-      break;
-    case "0.7.0":
-      switch (chain.id) {
-        default:
-          return "0x91E60e0613810449d098b0b5Ec8b51A0FE8c8985";
-      }
-  }
-
-  throw new DefaultFactoryNotDefinedError("SimpleAccount", chain, version);
-};
-
 export const minPriorityFeePerBidDefaults = new Map<number, bigint>([
   [arbitrum.id, 10_000_000n],
   [arbitrumGoerli.id, 10_000_000n],