@aa-sdk/core 4.0.0-alpha.0

package/src/errors/signer.ts

@@ -0,0 +1,13 @@
+import { BaseError } from "./base.js";
+
+export class InvalidSignerTypeError extends BaseError {
+  override name = "InvalidSignerTypeError";
+  constructor(signerType?: string) {
+    super(
+      [
+        "Invalid signer type parameter passed to SmartAccountSigner.",
+        signerType ?? "A signerType must be provided.",
+      ].join("\n")
+    );
+  }
+}

package/src/errors/transaction.ts

@@ -0,0 +1,16 @@
+import type { Hex } from "viem";
+import { BaseError } from "./base.js";
+
+export class TransactionMissingToParamError extends BaseError {
+  override name = "TransactionMissingToParamError";
+  constructor() {
+    super("Transaction is missing `to` address set on request");
+  }
+}
+
+export class FailedToFindTransactionError extends BaseError {
+  override name = "FailedToFindTransactionError";
+  constructor(hash: Hex) {
+    super(`Failed to find transaction for user operation ${hash}`);
+  }
+}

package/src/errors/useroperation.ts

@@ -0,0 +1,54 @@
+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
+ *
+ * extends viem BaseError
+ */
+export class InvalidUserOperationError extends BaseError {
+  /**
+   * @inheritdoc
+   */
+  override name = "InvalidUserOperationError";
+  /**
+   * Creates an instance of InvalidUserOperationError.
+   *
+   * InvalidUserOperationError constructor
+   *
+   * @param uo the invalid user operation struct
+   */
+  constructor(uo: UserOperationStruct) {
+    super(
+      `Request is missing parameters. All properties on UserOperationStruct must be set. uo: ${JSON.stringify(
+        uo,
+        (_key, value) =>
+          typeof value === "bigint"
+            ? {
+                type: "bigint",
+                value: value.toString(),
+              }
+            : value,
+        2
+      )}`
+    );
+  }
+}
+
+/**
+ * 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.
+ */
+export class WaitForUserOperationError extends BaseError {
+  /**
+   * @param request the user operation request that failed
+   * @param 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

@@ -0,0 +1,172 @@
+export type { Abi } from "abitype";
+export type { Address, HttpTransport } from "viem";
+export * as chains from "viem/chains";
+
+export { EntryPointAbi_v6 } from "./abis/EntryPointAbi_v6.js";
+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,
+  isSmartAccountWithSigner,
+  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";
+export { checkGasSponsorshipEligibility } from "./actions/smartAccount/checkGasSponsorshipEligibility.js";
+export { dropAndReplaceUserOperation } from "./actions/smartAccount/dropAndReplaceUserOperation.js";
+export { sendTransaction } from "./actions/smartAccount/sendTransaction.js";
+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,
+  createBundlerClientFromExisting,
+} from "./client/bundlerClient.js";
+export type * from "./client/decorators/bundlerClient.js";
+export { bundlerActions } from "./client/decorators/bundlerClient.js";
+export type * from "./client/decorators/smartAccountClient.js";
+export { smartAccountClientActions } from "./client/decorators/smartAccountClient.js";
+export { isSmartAccountClient } from "./client/isSmartAccountClient.js";
+export {
+  ConnectionConfigSchema,
+  SmartAccountClientOptsSchema,
+} from "./client/schema.js";
+export type * from "./client/smartAccountClient.js";
+export {
+  createSmartAccountClient,
+  createSmartAccountClientFromExisting,
+} from "./client/smartAccountClient.js";
+export type * from "./client/types.js";
+export {
+  convertChainIdToCoinType,
+  convertCoinTypeToChain,
+  convertCoinTypeToChainId,
+} from "./ens/utils.js";
+export {
+  defaultEntryPointVersion,
+  entryPointRegistry,
+  getEntryPoint,
+  isEntryPointVersion,
+} from "./entrypoint/index.js";
+export type * from "./entrypoint/types.js";
+export {
+  AccountNotFoundError,
+  AccountRequiresOwnerError,
+  BatchExecutionNotSupportedError,
+  DefaultFactoryNotDefinedError,
+  FailedToGetStorageSlotError,
+  GetCounterFactualAddressError,
+  IncorrectAccountType,
+  SignTransactionNotSupportedError,
+  SmartAccountWithSignerRequiredError,
+  UpgradeToAndCallNotSupportedError,
+  UpgradesNotSupportedError,
+} from "./errors/account.js";
+export { BaseError } from "./errors/base.js";
+export {
+  ChainNotFoundError,
+  IncompatibleClientError,
+  InvalidRpcUrlError,
+} from "./errors/client.js";
+export {
+  EntryPointNotFoundError,
+  InvalidEntryPointError,
+} from "./errors/entrypoint.js";
+export { InvalidSignerTypeError } from "./errors/signer.js";
+export {
+  FailedToFindTransactionError,
+  TransactionMissingToParamError,
+} from "./errors/transaction.js";
+export {
+  InvalidUserOperationError,
+  WaitForUserOperationError,
+} from "./errors/useroperation.js";
+export { LogLevel, Logger } from "./logger.js";
+export { middlewareActions } from "./middleware/actions.js";
+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 { noopMiddleware } from "./middleware/noopMiddleware.js";
+export type * from "./middleware/types.js";
+export { LocalAccountSigner } from "./signer/local-account.js";
+export { SignerSchema, isSigner } from "./signer/schema.js";
+export type {
+  SmartAccountAuthenticator,
+  SmartAccountSigner,
+} from "./signer/types.js";
+export {
+  verifyEIP6492Signature,
+  wrapSignatureWith6492,
+} from "./signer/utils.js";
+export { WalletClientSigner } from "./signer/wallet-client.js";
+export { split, type SplitTransportParams } from "./transport/split.js";
+export type * from "./types.js";
+export type * from "./utils/index.js";
+export {
+  AlchemyChainMap,
+  BigNumberishRangeSchema,
+  BigNumberishSchema,
+  ChainSchema,
+  HexSchema,
+  MultiplierSchema,
+  allEqual,
+  applyUserOpFeeOption,
+  applyUserOpOverride,
+  applyUserOpOverrideOrFeeOption,
+  asyncPipe,
+  bigIntMax,
+  bigIntMultiply,
+  bypassPaymasterAndData,
+  bypassPaymasterAndDataEmptyHex,
+  concatPaymasterAndData,
+  deepHexlify,
+  defineReadOnly,
+  filterUndefined,
+  getChain,
+  getDefaultSimpleAccountFactoryAddress,
+  getDefaultUserOperationFeeOptions,
+  isBigNumberish,
+  isMultiplier,
+  isValidRequest,
+  parsePaymasterAndData,
+  pick,
+  resolveProperties,
+  takeBytes,
+  toRecord,
+} from "./utils/index.js";

package/src/logger.ts

@@ -0,0 +1,58 @@
+export enum LogLevel {
+  VERBOSE = 5,
+  DEBUG = 4,
+  INFO = 3,
+  WARN = 2,
+  ERROR = 1,
+  NONE = 0,
+}
+
+export class Logger {
+  static logLevel: LogLevel = LogLevel.INFO;
+  static logFilter?: string;
+
+  static setLogLevel(logLevel: LogLevel) {
+    this.logLevel = logLevel;
+  }
+
+  static setLogFilter(pattern: string) {
+    this.logFilter = pattern;
+  }
+
+  static error(msg: string, ...args: any[]) {
+    if (!this.shouldLog(msg, LogLevel.ERROR)) return;
+
+    console.error(msg, ...args);
+  }
+
+  static warn(msg: string, ...args: any[]) {
+    if (!this.shouldLog(msg, LogLevel.WARN)) return;
+
+    console.warn(msg, ...args);
+  }
+
+  static debug(msg: string, ...args: any[]) {
+    if (!this.shouldLog(msg, LogLevel.DEBUG)) return;
+
+    console.debug(msg, ...args);
+  }
+
+  static info(msg: string, ...args: any[]) {
+    if (!this.shouldLog(msg, LogLevel.INFO)) return;
+
+    console.info(msg, ...args);
+  }
+
+  static verbose(msg: string, ...args: any[]) {
+    if (!this.shouldLog(msg, LogLevel.VERBOSE)) return;
+
+    console.log(msg, ...args);
+  }
+
+  private static shouldLog(msg: string, level: LogLevel) {
+    if (this.logLevel < level) return false;
+    if (this.logFilter && !msg.includes(this.logFilter)) return false;
+
+    return true;
+  }
+}

package/src/middleware/actions.ts

@@ -0,0 +1,92 @@
+import {
+  isHex,
+  type Chain,
+  type Client,
+  type PublicActions,
+  type PublicRpcSchema,
+  type Transport,
+} from "viem";
+import type { SmartContractAccount } from "../account/smartContractAccount.js";
+import type {
+  BundlerActions,
+  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";
+import { defaultUserOpSigner } from "./defaults/userOpSigner.js";
+import { noopMiddleware } from "./noopMiddleware.js";
+import type { ClientMiddleware } from "./types.js";
+
+/**
+ * Middleware client type
+ *
+ * @template {Transport} TTransport
+ * @template {Chain | undefined} TChain
+ * @template {SmartContractAccount | undefined} TAccount
+ */
+export type MiddlewareClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = Client<
+  TTransport,
+  TChain,
+  TAccount,
+  [...BundlerRpcSchema, ...PublicRpcSchema],
+  PublicActions & BundlerActions
+>;
+
+/**
+ * export function that takes in {@link 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
+ */
+export const middlewareActions =
+  (overrides: ClientMiddlewareConfig) =>
+  <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends SmartContractAccount | undefined =
+      | SmartContractAccount
+      | undefined
+  >(
+    client: MiddlewareClient<TTransport, TChain, TAccount>
+  ): { 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,
+
+      feeEstimator: overrides.feeEstimator ?? defaultFeeEstimator(client),
+      gasEstimator: overrides.gasEstimator ?? defaultGasEstimator(client),
+      paymasterAndData:
+        overrides.paymasterAndData?.paymasterAndData ?? defaultPaymasterAndData,
+      userOperationSimulator:
+        overrides.userOperationSimulator ?? noopMiddleware,
+      signUserOperation: overrides.signUserOperation ?? defaultUserOpSigner,
+    },
+  });

package/src/middleware/defaults/feeEstimator.ts

@@ -0,0 +1,50 @@
+import type { BigNumberish } from "../../types";
+import { applyUserOpOverrideOrFeeOption } from "../../utils/index.js";
+import type { MiddlewareClient } from "../actions";
+import type { ClientMiddlewareFn } from "../types";
+
+export const defaultFeeEstimator: <C extends MiddlewareClient>(
+  client: C
+) => ClientMiddlewareFn =
+  (client) =>
+  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
+    //
+    // Note that if maxFeePerGas is not at least the sum of maxPriorityFeePerGas and required baseFee
+    // after applying the fee options, then the transaction will fail
+    //
+    // Refer to https://docs.alchemy.com/docs/maxpriorityfeepergas-vs-maxfeepergas
+    // for more information about maxFeePerGas and maxPriorityFeePerGas
+
+    const feeData = await client.estimateFeesPerGas();
+    if (!feeData.maxFeePerGas || feeData.maxPriorityFeePerGas == null) {
+      throw new Error(
+        "feeData is missing maxFeePerGas or maxPriorityFeePerGas"
+      );
+    }
+
+    let maxPriorityFeePerGas: BigNumberish =
+      await client.estimateMaxPriorityFeePerGas();
+
+    maxPriorityFeePerGas = applyUserOpOverrideOrFeeOption(
+      maxPriorityFeePerGas,
+      overrides?.maxPriorityFeePerGas,
+      feeOptions?.maxPriorityFeePerGas
+    );
+
+    let maxFeePerGas: BigNumberish =
+      feeData.maxFeePerGas -
+      feeData.maxPriorityFeePerGas +
+      BigInt(maxPriorityFeePerGas);
+
+    maxFeePerGas = applyUserOpOverrideOrFeeOption(
+      maxFeePerGas,
+      overrides?.maxFeePerGas,
+      feeOptions?.maxFeePerGas
+    );
+
+    struct.maxFeePerGas = maxFeePerGas;
+    struct.maxPriorityFeePerGas = maxPriorityFeePerGas;
+    return struct;
+  };

package/src/middleware/defaults/gasEstimator.ts

@@ -0,0 +1,66 @@
+import type {
+  UserOperationFeeOptions,
+  UserOperationOverrides,
+  UserOperationStruct,
+} from "../../types.js";
+import { deepHexlify, resolveProperties } from "../../utils/index.js";
+import { applyUserOpOverrideOrFeeOption } from "../../utils/userop.js";
+import type { MiddlewareClient } from "../actions.js";
+import type { ClientMiddlewareFn } from "../types.js";
+
+/**
+ * Description default gas estimator middleware for `SmartAccountClient`
+ * 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
+ */
+export const defaultGasEstimator: <C extends MiddlewareClient>(
+  client: C
+) => ClientMiddlewareFn =
+  (client) =>
+  async (struct, { account, overrides, feeOptions }) => {
+    const request = deepHexlify(await resolveProperties(struct));
+
+    const estimates = await client.estimateUserOperationGas(
+      request,
+      account.getEntryPoint().address,
+      overrides?.stateOverride
+    );
+
+    const callGasLimit = applyUserOpOverrideOrFeeOption(
+      estimates.callGasLimit,
+      overrides?.callGasLimit,
+      feeOptions?.callGasLimit
+    );
+    const verificationGasLimit = applyUserOpOverrideOrFeeOption(
+      estimates.verificationGasLimit,
+      overrides?.verificationGasLimit,
+      feeOptions?.verificationGasLimit
+    );
+    const preVerificationGas = applyUserOpOverrideOrFeeOption(
+      estimates.preVerificationGas,
+      overrides?.preVerificationGas,
+      feeOptions?.preVerificationGas
+    );
+
+    struct.callGasLimit = callGasLimit;
+    struct.verificationGasLimit = verificationGasLimit;
+    struct.preVerificationGas = preVerificationGas;
+
+    const entryPoint = account.getEntryPoint();
+    if (entryPoint.version === "0.7.0") {
+      const paymasterVerificationGasLimit = applyUserOpOverrideOrFeeOption(
+        estimates.paymasterVerificationGasLimit,
+        (overrides as UserOperationOverrides<"0.7.0">)
+          ?.paymasterVerificationGasLimit,
+        (feeOptions as UserOperationFeeOptions<"0.7.0">)
+          ?.paymasterVerificationGasLimit
+      );
+      (struct as UserOperationStruct<"0.7.0">).paymasterVerificationGasLimit =
+        paymasterVerificationGasLimit;
+    }
+
+    return struct;
+  };

package/src/middleware/defaults/paymasterAndData.ts

@@ -0,0 +1,13 @@
+import type { UserOperationStruct } from "../../types";
+import type { ClientMiddlewareFn } from "../types";
+
+export const defaultPaymasterAndData: ClientMiddlewareFn = async (
+  struct,
+  { account }
+) => {
+  const entryPoint = account.getEntryPoint();
+  if (entryPoint.version === "0.6.0") {
+    (struct as UserOperationStruct<"0.6.0">).paymasterAndData = "0x";
+  }
+  return struct;
+};

package/src/middleware/defaults/userOpSigner.ts

@@ -0,0 +1,35 @@
+import { AccountNotFoundError } from "../../errors/account.js";
+import { ChainNotFoundError } from "../../errors/client.js";
+import { InvalidUserOperationError } from "../../errors/useroperation.js";
+import {
+  deepHexlify,
+  isValidRequest,
+  resolveProperties,
+} from "../../utils/index.js";
+import type { ClientMiddlewareFn } from "../types";
+
+export const defaultUserOpSigner: ClientMiddlewareFn = async (
+  struct,
+  { client, account = client.account }
+) => {
+  if (!account) {
+    throw new AccountNotFoundError();
+  }
+
+  if (!client?.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const resolvedStruct = await resolveProperties(struct);
+  const request = deepHexlify(resolvedStruct);
+  if (!isValidRequest(request)) {
+    throw new InvalidUserOperationError(resolvedStruct);
+  }
+
+  return {
+    ...resolvedStruct,
+    signature: await account.signUserOperationHash(
+      account.getEntryPoint().getUserOperationHash(request)
+    ),
+  };
+};

package/src/middleware/noopMiddleware.ts

@@ -0,0 +1,12 @@
+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
+ */
+export const noopMiddleware: ClientMiddlewareFn = async (args) => {
+  return args;
+};

package/src/middleware/types.ts

@@ -0,0 +1,49 @@
+import type {
+  GetEntryPointFromAccount,
+  SmartContractAccount,
+} from "../account/smartContractAccount";
+import type { UserOperationContext } from "../actions/smartAccount/types";
+import type {
+  UserOperationFeeOptions,
+  UserOperationOverrides,
+  UserOperationStruct,
+} from "../types";
+import type { Deferrable } from "../utils";
+import type { MiddlewareClient } from "./actions";
+
+// [!region ClientMiddlewareFn]
+export type ClientMiddlewareFn<
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = <
+  TAccount extends SmartContractAccount,
+  C extends MiddlewareClient,
+  TEntryPointVersion extends GetEntryPointFromAccount<TAccount> = GetEntryPointFromAccount<TAccount>
+>(
+  struct: Deferrable<UserOperationStruct<TEntryPointVersion>>,
+  args: {
+    overrides?: UserOperationOverrides<TEntryPointVersion>;
+    context?: TContext;
+    feeOptions?: UserOperationFeeOptions;
+    account: TAccount;
+    client: C;
+  }
+) => Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>;
+// [!endregion ClientMiddlewareFn]
+
+// [!region ClientMiddleware]
+export type ClientMiddleware<
+  TContext extends UserOperationContext | undefined =
+    | UserOperationContext
+    | undefined
+> = {
+  dummyPaymasterAndData: ClientMiddlewareFn<TContext>;
+  feeEstimator: ClientMiddlewareFn<TContext>;
+  gasEstimator: ClientMiddlewareFn<TContext>;
+  customMiddleware: ClientMiddlewareFn<TContext>;
+  paymasterAndData: ClientMiddlewareFn<TContext>;
+  userOperationSimulator: ClientMiddlewareFn<TContext>;
+  signUserOperation: ClientMiddlewareFn<TContext>;
+};
+// [!endregion ClientMiddleware]