@aa-sdk/core 4.0.0-alpha.0

package/src/types.ts

@@ -0,0 +1,411 @@
+import {
+  type Address,
+  type Hash,
+  type Hex,
+  type StateOverride,
+  type TransactionReceipt,
+} from "viem";
+import type { z } from "zod";
+import type {
+  UserOperationFeeOptionsFieldSchema,
+  UserOperationFeeOptionsSchema,
+  UserOperationFeeOptionsSchema_v6,
+  UserOperationFeeOptionsSchema_v7,
+} from "./client/schema";
+import type { EntryPointVersion } from "./entrypoint/types";
+import type {
+  BigNumberishRangeSchema,
+  BigNumberishSchema,
+  MultiplierSchema,
+  NoUndefined,
+} from "./utils";
+
+export type EmptyHex = `0x`;
+export type NullAddress = `0x0`;
+
+// based on @account-abstraction/common
+export type PromiseOrValue<T> = T | Promise<T>;
+export type BytesLike = Uint8Array | Hex;
+export type Multiplier = z.input<typeof MultiplierSchema>;
+
+export type BigNumberish = z.input<typeof BigNumberishSchema>;
+export type BigNumberishRange = z.input<typeof BigNumberishRangeSchema>;
+
+// [!region UserOperationCallData]
+export type UserOperationCallData =
+  | {
+      /* the target of the call */
+      target: Address;
+      /* the data passed to the target */
+      data: Hex;
+      /* the amount of native token to send to the target (default: 0) */
+      value?: bigint;
+    }
+  | Hex;
+// [!endregion UserOperationCallData]
+
+// [!region BatchUserOperationCallData]
+export type BatchUserOperationCallData = Exclude<UserOperationCallData, Hex>[];
+// [!endregion BatchUserOperationCallData]
+
+export type UserOperationFeeOptionsField = z.input<
+  typeof UserOperationFeeOptionsFieldSchema
+>;
+
+export type UserOperationFeeOptions<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = TEntryPointVersion extends "0.6.0"
+  ? z.input<typeof UserOperationFeeOptionsSchema_v6>
+  : TEntryPointVersion extends "0.7.0"
+  ? z.input<typeof UserOperationFeeOptionsSchema_v7>
+  : z.input<typeof UserOperationFeeOptionsSchema>;
+
+export type UserOperationOverridesParameter<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion,
+  Required extends boolean = false
+> = Required extends true
+  ? { overrides: UserOperationOverrides<TEntryPointVersion> }
+  : { overrides?: UserOperationOverrides<TEntryPointVersion> };
+
+// [!region UserOperationPaymasterOverrides]
+export type UserOperationPaymasterOverrides<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = TEntryPointVersion extends "0.6.0"
+  ? {
+      // paymasterData overrides to bypass paymaster middleware
+      paymasterAndData: Hex;
+    }
+  : TEntryPointVersion extends "0.7.0"
+  ? {
+      // paymasterData overrides to bypass paymaster middleware
+      // if set to '0x', all paymaster related fields are omitted from the user op request
+      paymasterData: Hex;
+      paymaster: Address;
+      paymasterVerificationGasLimit:
+        | NoUndefined<
+            UserOperationStruct<"0.7.0">["paymasterVerificationGasLimit"]
+          >
+        | Multiplier;
+      paymasterPostOpGasLimit:
+        | NoUndefined<UserOperationStruct<"0.7.0">["paymasterPostOpGasLimit"]>
+        | Multiplier;
+    }
+  : {};
+// [!endregion UserOperationOverridesParameter]
+
+// [!region UserOperationOverrides]
+export type UserOperationOverrides<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = Partial<
+  {
+    callGasLimit:
+      | UserOperationStruct<TEntryPointVersion>["callGasLimit"]
+      | Multiplier;
+    maxFeePerGas:
+      | UserOperationStruct<TEntryPointVersion>["maxFeePerGas"]
+      | Multiplier;
+    maxPriorityFeePerGas:
+      | UserOperationStruct<TEntryPointVersion>["maxPriorityFeePerGas"]
+      | Multiplier;
+    preVerificationGas:
+      | UserOperationStruct<TEntryPointVersion>["preVerificationGas"]
+      | Multiplier;
+    verificationGasLimit:
+      | UserOperationStruct<TEntryPointVersion>["verificationGasLimit"]
+      | Multiplier;
+    /**
+     * This can be used to override the key used when calling `entryPoint.getNonce`
+     * It is useful when you want to use parallel nonces for user operations
+     *
+     * NOTE: not all bundlers fully support this feature and it could be that your bundler will still only include
+     * one user operation for your account in a bundle
+     */
+    nonceKey: bigint;
+
+    /**
+     * The same state overrides for
+     * [`eth_call`](https://geth.ethereum.org/docs/interacting-with-geth/rpc/ns-eth#eth-call) method.
+     * An address-to-state mapping, where each entry specifies some state to be ephemerally overridden
+     * prior to executing the call. State overrides allow you to customize the network state for
+     * the purpose of the simulation, so this feature is useful when you need to estimate gas
+     * for user operation scenarios under conditions that aren’t currently present on the live network.
+     */
+    stateOverride: StateOverride;
+  } & UserOperationPaymasterOverrides<TEntryPointVersion>
+>;
+// [!endregion UserOperationOverrides]
+
+// [!region UserOperationRequest_v6]
+// represents the request as it needs to be formatted for v0.6 RPC requests
+// Reference: https://github.com/ethereum/ERCs/blob/8dd085d159cb123f545c272c0d871a5339550e79/ERCS/erc-4337.md#definitions
+export interface UserOperationRequest_v6 {
+  /* the origin of the request */
+  sender: Address;
+  /* nonce (as hex) of the transaction, returned from the entry point for this Address */
+  nonce: Hex;
+  /* the initCode for creating the sender if it does not exist yet, otherwise "0x" */
+  initCode: Hex | EmptyHex;
+  /* the callData passed to the target */
+  callData: Hex;
+  /* Gas value (as hex) used by inner account execution */
+  callGasLimit: Hex;
+  /* Actual gas (as hex) used by the validation of this UserOperation */
+  verificationGasLimit: Hex;
+  /* Gas overhead (as hex) of this UserOperation */
+  preVerificationGas: Hex;
+  /* Maximum fee per gas (similar to EIP-1559 max_fee_per_gas) (as hex)*/
+  maxFeePerGas: Hex;
+  /* Maximum priority fee per gas (similar to EIP-1559 max_priority_fee_per_gas) (as hex)*/
+  maxPriorityFeePerGas: Hex;
+  /* Address of paymaster sponsoring the transaction, followed by extra data to send to the paymaster ("0x" for self-sponsored transaction) */
+  paymasterAndData: Hex | EmptyHex;
+  /* Data passed into the account along with the nonce during the verification step */
+  signature: Hex;
+}
+// [!endregion UserOperationRequest_v6]
+
+// [!region UserOperationRequest_v7]
+// represents the request as it needs to be formatted for v0.7 RPC requests
+// Reference: https://eips.ethereum.org/EIPS/eip-4337#definitions
+export interface UserOperationRequest_v7 {
+  /* the account making the operation */
+  sender: Address;
+  /* anti-replay parameter. nonce of the transaction, returned from the entry point for this address */
+  nonce: Hex;
+  /* account factory, only for new accounts */
+  factory?: Address;
+  /* data for account factory (only if account factory exists) */
+  factoryData?: Hex;
+  /* the data to pass to the sender during the main execution call */
+  callData: Hex;
+  /* the amount of gas to allocate the main execution call */
+  callGasLimit: Hex;
+  /* the amount of gas to allocate for the verification step */
+  verificationGasLimit: Hex;
+  /* extra gas to pay the bunder */
+  preVerificationGas: Hex;
+  /* maximum fee per gas (similar to EIP-1559 max_fee_per_gas) */
+  maxFeePerGas: Hex;
+  /* maximum priority fee per gas (similar to EIP-1559 max_priority_fee_per_gas) */
+  maxPriorityFeePerGas: Hex;
+  /* address of paymaster contract, (or empty, if account pays for itself) */
+  paymaster?: Address;
+  /* the amount of gas to allocate for the paymaster validation code */
+  paymasterVerificationGasLimit?: Hex;
+  /* the amount of gas to allocate for the paymaster post-operation code */
+  paymasterPostOpGasLimit?: Hex;
+  /* data for paymaster (only if paymaster exists) */
+  paymasterData?: Hex;
+  /* data passed into the account to verify authorization */
+  signature: Hex;
+}
+// [!endregion UserOperationRequest_v7]
+
+// [!region UserOperationRequest]
+// Reference: https://eips.ethereum.org/EIPS/eip-4337#definitions
+export type UserOperationRequest<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = TEntryPointVersion extends "0.6.0"
+  ? UserOperationRequest_v6
+  : TEntryPointVersion extends "0.7.0"
+  ? UserOperationRequest_v7
+  : never;
+
+// [!endregion UserOperationRequest]
+
+// [!region UserOperationEstimateGasResponse]
+export interface UserOperationEstimateGasResponse<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> {
+  /* Gas overhead of this UserOperation */
+  preVerificationGas: BigNumberish;
+  /* Actual gas used by the validation of this UserOperation */
+  verificationGasLimit: BigNumberish;
+  /* Value used by inner account execution */
+  callGasLimit: BigNumberish;
+  /*
+   * EntryPoint v0.7.0 operations only.
+   * The amount of gas to allocate for the paymaster validation code.
+   * Note: `eth_estimateUserOperationGas` does not return paymasterPostOpGasLimit.
+   */
+  paymasterVerificationGasLimit: TEntryPointVersion extends "0.7.0"
+    ? BigNumberish | undefined
+    : never;
+}
+// [!endregion UserOperationEstimateGasResponse]
+
+// [!region UserOperationResponse]
+export interface UserOperationResponse<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> {
+  /* the User Operation */
+  userOperation: UserOperationRequest<TEntryPointVersion>;
+  /* the address of the entry point contract that executed the user operation */
+  entryPoint: Address;
+  /* the block number the user operation was included in */
+  blockNumber: BigNumberish;
+  /* the hash of the block the user operation was included in */
+  blockHash: Hash;
+  /* the hash of the transaction that included the user operation */
+  transactionHash: Hash;
+}
+// [!endregion UserOperationResponse]
+
+// [!region UserOperationReceipt]
+export interface UserOperationReceipt {
+  /* The request hash of the UserOperation. */
+  userOpHash: Hash;
+  /* The entry point address used for the UserOperation. */
+  entryPoint: Address;
+  /* The account initiating the UserOperation. */
+  sender: Address;
+  /* The nonce used in the UserOperation. */
+  nonce: BigNumberish;
+  /* The paymaster used for this UserOperation (or empty). */
+  paymaster?: Address;
+  /* The actual amount paid (by account or paymaster) for this UserOperation. */
+  actualGasCost: BigNumberish;
+  /* The total gas used by this UserOperation (including preVerification, creation, validation, and execution). */
+  actualGasUsed: BigNumberish;
+  /* Indicates whether the execution completed without reverting. */
+  success: boolean;
+  /* In case of revert, this is the revert reason. */
+  reason?: string;
+  /* The logs generated by this UserOperation (not including logs of other UserOperations in the same bundle). */
+  logs: string[];
+  /* The TransactionReceipt object for the entire bundle, not only for this UserOperation. */
+  receipt: TransactionReceipt;
+}
+// [!endregion UserOperationReceipt]
+
+/** @deprecated use viem type TransactionReceipt instead */
+export interface UserOperationReceiptObject {
+  /* 32 Bytes - hash of the block where this log was in. null when its pending. null when its pending log */
+  blockHash: Hash;
+  /* The block number where this log was in. null when its pending. null when its pending log. */
+  blockNumber: BigNumberish;
+  /* The index of the transaction within the block. */
+  transactionIndex: BigNumberish;
+  /* 32 Bytes - hash of the transaction. null when its pending. */
+  transactionHash: Hash;
+  /* 20 Bytes - address of the sender */
+  from: Address;
+  /* 20 Bytes - address of the receiver. null when its a contract creation transaction */
+  to: Address;
+  /* The total amount of gas used when this transaction was executed in the block. */
+  cumulativeGasUsed: BigNumberish;
+  /* The amount of gas used by this specific transaction alone */
+  gasUsed: BigNumberish;
+  /* 20 Bytes - The contract address created, if the transaction was a contract creation, otherwise null */
+  contractAddress: Address;
+  logs: UserOperationReceiptLog[];
+  /* 256 Bytes - Bloom filter for light clients to quickly retrieve related logs */
+  logsBloom: Hex;
+  /* 32 bytes of post-transaction stateroot. (pre Byzantium hard fork at block 4,370,000) */
+  root: Hex;
+  /* Either 1 (success) or 0 (failure). (post Byzantium hard fork at block 4,370,000) */
+  status: number;
+  /* The cumulative gas used in the block containing this UserOperation. */
+  effectiveGasPrice: BigNumberish;
+  /* The type of the recipt object */
+  type: string;
+}
+
+/** @deprecated use viem type Log instead */
+/* https://github.com/wevm/viem/blob/6ef4ac131a878bf1dc4b335f5dc127e62618dda0/src/types/log.ts#L15 */
+export interface UserOperationReceiptLog {
+  /* The hash of the block where the given transaction was included. */
+  blockHash: Hash;
+  /* The number of the block where the given transaction was included. */
+  blockNumber: BigNumberish;
+  /* The index of the transaction within the block. */
+  transactionIndex: BigNumberish;
+  /* 20 Bytes - address from which this log originated. */
+  address: Address;
+  /* Integer of the log index position in the block. null when its pending log. */
+  logIndex: BigNumberish;
+  /* Contains one or more 32 Bytes non-indexed arguments of the log. */
+  data: Hex;
+  /* true when the log was removed, due to a chain reorganization. false if its a valid log. */
+  removed: boolean;
+  /* Array of zero to four 32 Bytes DATA of indexed log arguments. */
+  topics: string[];
+  /* hash of the transaction */
+  transactionHash: Hash;
+}
+
+// [!region UserOperationStruct_v6]
+// https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.6/test/UserOperation.ts
+// this is used for building requests for v0.6 entry point contract
+export interface UserOperationStruct_v6 {
+  /* the origin of the request */
+  sender: string;
+  /* nonce of the transaction, returned from the entry point for this address */
+  nonce: BigNumberish;
+  /* the initCode for creating the sender if it does not exist yet, otherwise "0x" */
+  initCode: BytesLike | "0x";
+  /* the callData passed to the target */
+  callData: BytesLike;
+  /* Value used by inner account execution */
+  callGasLimit?: BigNumberish;
+  /* Actual gas used by the validation of this UserOperation */
+  verificationGasLimit?: BigNumberish;
+  /* Gas overhead of this UserOperation */
+  preVerificationGas?: BigNumberish;
+  /* Maximum fee per gas (similar to EIP-1559 max_fee_per_gas) */
+  maxFeePerGas?: BigNumberish;
+  /* Maximum priority fee per gas (similar to EIP-1559 max_priority_fee_per_gas) */
+  maxPriorityFeePerGas?: BigNumberish;
+  /* Address of paymaster sponsoring the transaction, followed by extra data to send to the paymaster ("0x" for self-sponsored transaction) */
+  paymasterAndData: BytesLike | "0x";
+  /* Data passed into the account along with the nonce during the verification step */
+  signature: BytesLike;
+}
+// [!endregion UserOperationStruct_v6]
+
+// [!region UserOperationStruct_v7]
+// based on https://github.com/eth-infinitism/account-abstraction/blob/releases/v0.7/test/UserOperation.ts
+// this is used for building requests for v0.7 entry point contract
+export interface UserOperationStruct_v7 {
+  /* the account making the operation */
+  sender: string;
+  /* anti-replay parameter. nonce of the transaction, returned from the entry point for this address */
+  nonce: BigNumberish;
+  /* account factory, only for new accounts */
+  factory?: string;
+  /* data for account factory (only if account factory exists) */
+  factoryData?: BytesLike;
+  /* the data to pass to the sender during the main execution call */
+  callData: BytesLike;
+  /* the amount of gas to allocate the main execution call */
+  callGasLimit?: BigNumberish;
+  /* the amount of gas to allocate for the verification step */
+  verificationGasLimit?: BigNumberish;
+  /* extra gas to pay the bunder */
+  preVerificationGas?: BigNumberish;
+  /* maximum fee per gas (similar to EIP-1559 max_fee_per_gas) */
+  maxFeePerGas?: BigNumberish;
+  /* maximum priority fee per gas (similar to EIP-1559 max_priority_fee_per_gas) */
+  maxPriorityFeePerGas?: BigNumberish;
+  /* address of paymaster contract, (or empty, if account pays for itself) */
+  paymaster?: string;
+  /* the amount of gas to allocate for the paymaster validation code */
+  paymasterVerificationGasLimit?: BigNumberish;
+  /* the amount of gas to allocate for the paymaster post-operation code */
+  paymasterPostOpGasLimit?: BigNumberish;
+  /* data for paymaster (only if paymaster exists) */
+  paymasterData?: BytesLike;
+  /* data passed into the account to verify authorization */
+  signature: BytesLike;
+}
+// [!endregion UserOperationStruct_v7]
+
+// [!region UserOperationStruct]
+export type UserOperationStruct<
+  TEntryPointVersion extends EntryPointVersion = EntryPointVersion
+> = TEntryPointVersion extends "0.6.0"
+  ? UserOperationStruct_v6
+  : TEntryPointVersion extends "0.7.0"
+  ? UserOperationStruct_v7
+  : never;
+// [!endregion UserOperationStruct]

package/src/utils/bigint.ts

@@ -0,0 +1,118 @@
+import { keccak256, toHex } from "viem";
+import type { BigNumberish, Multiplier } from "../types";
+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
+ */
+export const bigIntMax = (...args: bigint[]): bigint => {
+  if (!args.length) {
+    throw new Error("bigIntMax requires at least one argument");
+  }
+
+  return args.reduce((m, c) => (m > c ? m : c));
+};
+
+/**
+ * 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
+ */
+export const bigIntMin = (...args: bigint[]): bigint => {
+  if (!args.length) {
+    throw new Error("bigIntMin requires at least one argument");
+  }
+
+  return args.reduce((m, c) => (m < c ? m : c));
+};
+
+/**
+ * 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
+ */
+export const bigIntClamp = (
+  value: BigNumberish,
+  lower: BigNumberish | null | undefined,
+  upper: BigNumberish | null | undefined
+) => {
+  lower = lower != null ? BigInt(lower) : null;
+  upper = upper != null ? BigInt(upper) : null;
+
+  if (upper != null && lower != null && upper < lower) {
+    throw new Error(
+      `invalid range: upper bound ${upper} is less than lower bound ${lower}`
+    );
+  }
+
+  let ret = BigInt(value);
+  if (lower != null && lower > ret) {
+    ret = lower;
+  }
+  if (upper != null && upper < ret) {
+    ret = upper;
+  }
+  return ret;
+};
+
+export enum RoundingMode {
+  ROUND_DOWN = 0,
+  ROUND_UP = 1,
+}
+
+/**
+ * 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
+ */
+export const bigIntMultiply = (
+  base: BigNumberish,
+  multiplier: Multiplier["multiplier"],
+  roundingMode: RoundingMode = RoundingMode.ROUND_UP
+) => {
+  if (!isMultiplier({ multiplier })) {
+    throw new Error(
+      "bigIntMultiply requires a multiplier validated number as the second argument"
+    );
+  }
+
+  // Get decimal places of b. Max decimal places is defined by the MultiplerSchema.
+  const decimalPlaces = multiplier.toString().split(".")[1]?.length ?? 0;
+  const val =
+    roundingMode === RoundingMode.ROUND_UP
+      ? BigInt(base) * BigInt(multiplier * 10 ** decimalPlaces) +
+        BigInt(10 ** decimalPlaces - 1)
+      : BigInt(base) * BigInt(multiplier * 10 ** decimalPlaces);
+
+  return val / BigInt(10 ** decimalPlaces);
+};
+
+/**
+ * Useful if you want to use a string, such as a user's email address, as salt to generate a unique SmartAccount per user.
+ *
+ * example:
+ * ```
+ * const salt = stringToIndex("alice@example.com");
+ *
+ * export const account = new SimpleSmartContractAccount({
+ *   index: salt,
+ *   // other args omitted...
+ * });
+ * ```
+ *
+ * @param phrase -- any string value.
+ * @returns the bigint value of the hashed string
+ */
+export const stringToIndex = (phrase: string): bigint =>
+  BigInt(keccak256(toHex(phrase)));

package/src/utils/bytes.ts

@@ -0,0 +1,23 @@
+import type { Hex } from "viem";
+
+type TakeBytesOpts = {
+  count?: number;
+  offset?: number;
+};
+
+/**
+ * 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
+ */
+export const takeBytes = (bytes: Hex, opts: TakeBytesOpts = {}): Hex => {
+  const { offset, count } = opts;
+  const start = (offset ? offset * 2 : 0) + 2; // add 2 to skip the 0x prefix
+  const end = count ? start + count * 2 : undefined;
+
+  return `0x${bytes.slice(start, end)}`;
+};

package/src/utils/defaults.ts

@@ -0,0 +1,93 @@
+import { type Address, type Chain } from "viem";
+import {
+  arbitrum,
+  arbitrumGoerli,
+  arbitrumSepolia,
+  base,
+  baseGoerli,
+  baseSepolia,
+  fraxtal,
+  fraxtalSepolia,
+  goerli,
+  mainnet,
+  optimism,
+  optimismGoerli,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  polygonMumbai,
+  sepolia,
+  zora,
+  zoraSepolia,
+} from "../chains/index.js";
+import { defaultEntryPointVersion } from "../entrypoint/index.js";
+import type { EntryPointVersion } from "../entrypoint/types.js";
+import { DefaultFactoryNotDefinedError } from "../errors/account.js";
+import type { UserOperationFeeOptions } from "../types";
+
+/**
+ * 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 fraxtalSepolia.id:
+        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],
+  [arbitrumSepolia.id, 10_000_000n],
+]);
+
+export const getDefaultUserOperationFeeOptions = (
+  chain: Chain
+): UserOperationFeeOptions => {
+  return {
+    maxPriorityFeePerGas: {
+      min: minPriorityFeePerBidDefaults.get(chain.id) ?? 100_000_000n,
+      multiplier: 1.33,
+    },
+  };
+};