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

package/src/errors/account.ts

@@ -2,17 +2,35 @@ import type { Chain } from "viem";
 import type { EntryPointVersion } from "../entrypoint/types.js";
 import { BaseError } from "./base.js";
 
+/**
+ * This error is thrown when an account could not be found to execute a specific action. It extends the `BaseError` class.
+ */
 export class AccountNotFoundError extends BaseError {
   override name = "AccountNotFoundError";
 
   // TODO: extend this further using docs path as well
-  constructor() {
+
+  /**
+   * Constructor for initializing an error message indicating that an account could not be found to execute the specified action.
+   */ constructor() {
     super("Could not find an Account to execute with this Action.");
   }
 }
 
+/**
+ * Represents an error that is thrown when no default factory is defined for a specific account type on a given chain and entry point version.
+ * This error suggests providing an override via the `factoryAddress` parameter when creating an account.
+ */
 export class DefaultFactoryNotDefinedError extends BaseError {
   override name = "DefaultFactoryNotDefinedError";
+
+  /**
+   * Constructs an error message indicating that no default factory was found for the given account type, chain, and entry point version.
+   *
+   * @param {string} accountType the type of account
+   * @param {Chain} chain the blockchain chain
+   * @param {EntryPointVersion} version the entry point version
+   */
   constructor(accountType: string, chain: Chain, version: EntryPointVersion) {
     super(
       [
@@ -23,65 +41,141 @@ export class DefaultFactoryNotDefinedError extends BaseError {
   }
 }
 
+/**
+ * Custom error class for handling errors when getting a counterfactual address. This extends the `BaseError` class and provides a custom error message and name.
+ */
 export class GetCounterFactualAddressError extends BaseError {
   override name = "GetCounterFactualAddressError";
-  constructor() {
+
+  /**
+   * Constructor for initializing an error message indicating the failure of fetching the counter-factual address.
+   */ constructor() {
     super("getCounterFactualAddress failed");
   }
 }
 
+/**
+ * An error class representing the condition where upgrades are not supported for a specific account type. This error extends the `BaseError` class and provides a custom error message based on the account type.
+ */
 export class UpgradesNotSupportedError extends BaseError {
   override name = "UpgradesNotSupported";
+
+  /**
+   * Error constructor for indicating that upgrades are not supported by the given account type.
+   *
+   * @param {string} accountType The type of account that does not support upgrades
+   */
   constructor(accountType: string) {
     super(`Upgrades are not supported by ${accountType}`);
   }
 }
 
+/**
+ * Error thrown when attempting to sign a transaction that is not supported by smart contracts.
+ */
 export class SignTransactionNotSupportedError extends BaseError {
   override name = "SignTransactionNotSupported";
-  constructor() {
+
+  /**
+   * Throws an error indicating that signing a transaction is not supported by smart contracts.
+   *
+   
+   */ constructor() {
     super(`SignTransaction is not supported by smart contracts`);
   }
 }
 
+/**
+ * Custom error class `FailedToGetStorageSlotError` which is used to signal a failure when attempting to retrieve a storage slot. This error includes the slot and slot descriptor in its message and inherits from `BaseError`.
+ */
 export class FailedToGetStorageSlotError extends BaseError {
   override name = "FailedToGetStorageSlotError";
+
+  /**
+   * Custom error message constructor for failing to get a specific storage slot.
+   *
+   * @param {string} slot The storage slot that failed to be accessed or retrieved
+   * @param {string} slotDescriptor A description of the storage slot, for additional context in the error message
+   */
   constructor(slot: string, slotDescriptor: string) {
     super(`Failed to get storage slot ${slot} (${slotDescriptor})`);
   }
 }
 
+/**
+ * Represents an error indicating that batch execution is not supported for a specific account type.
+ */
 export class BatchExecutionNotSupportedError extends BaseError {
   override name = "BatchExecutionNotSupportedError";
+
+  /**
+   * Constructs an error message indicating that batch execution is not supported by the specified account type.
+   *
+   * @param {string} accountType the type of account that does not support batch execution
+   */
   constructor(accountType: string) {
     super(`Batch execution is not supported by ${accountType}`);
   }
 }
 
+/**
+ * Represents an error that occurs when an account requires an owner to execute but none is provided.
+ */
 export class AccountRequiresOwnerError extends BaseError {
   override name = "AccountRequiresOwnerError";
+
+  /**
+   * Constructs an error indicating that an account of the specified type requires an owner to execute.
+   *
+   * @param {string} accountType The type of account that requires an owner
+   */
   constructor(accountType: string) {
     super(`Account of type ${accountType} requires an owner to execute`);
   }
 }
 
+/**
+ * Represents an error that occurs when an attempt is made to call `UpgradeToAndCall` on an account type that does not support it. Includes the account type in the error message.
+ */
 export class UpgradeToAndCallNotSupportedError extends BaseError {
   override name = "UpgradeToAndCallNotSupportedError";
+
+  /**
+   * Constructs an error message indicating that `UpgradeToAndCall` is not supported by the specified account type.
+   *
+   * @param {string} accountType The type of account that does not support `UpgradeToAndCall`
+   */
   constructor(accountType: string) {
     super(`UpgradeToAndCall is not supported by ${accountType}`);
   }
 }
 
+/**
+ * Represents an error thrown when an account type does not match the expected type.
+ */
 export class IncorrectAccountType extends BaseError {
   override name = "IncorrectAccountTypeError";
+
+  /**
+   * Constructs an error object indicating that the expected account type does not match the actual account type.
+   *
+   * @param {string} expected the expected account type
+   * @param {string} actual the actual account type that was received
+   */
   constructor(expected: string, actual: string) {
     super(`Expected account type ${expected}, got ${actual}`);
   }
 }
 
+/**
+ * Error class indicating that a smart account operation requires a signer.
+ */
 export class SmartAccountWithSignerRequiredError extends BaseError {
   override name = "SmartAccountWithSignerRequiredError";
-  constructor() {
+
+  /**
+   * Initializes a new instance of the error class with a predefined error message indicating that a smart account requires a signer.
+   */ constructor() {
     super("Smart account requires a signer");
   }
 }

package/src/errors/base.ts

@@ -16,8 +16,11 @@ type BaseErrorParameters = {
     }
 );
 
-// This is based on on viem's BaseError type (obviously from the import and extend)
-// we want the errors here to point to our docs if we supply a docsPath though
+/**
+ * A custom error class that extends from `ViemBaseError`. This class allows for error messages to include links to relevant documentation based on provided `docsPath` and `docsSlug` parameters.
+ * This is based on on viem's BaseError type (obviously from the import and extend)
+ * we want the errors here to point to our docs if we supply a docsPath though
+ */
 export class BaseError extends ViemBaseError {
   override name = "AASDKError";
   override version = VERSION;

package/src/errors/client.ts

@@ -1,8 +1,19 @@
 import type { Client } from "viem";
 import { BaseError } from "./base.js";
 
+/**
+ * Represents an error thrown when a client is not compatible with the expected client type for a specific method. The error message provides guidance on how to create a compatible client.
+ */
 export class IncompatibleClientError extends BaseError {
   override name = "IncompatibleClientError";
+
+  /**
+   * Throws an error when the client type does not match the expected client type.
+   *
+   * @param {string} expectedClient The expected type of the client.
+   * @param {string} method The method that was called.
+   * @param {Client} client The client instance.
+   */
   constructor(expectedClient: string, method: string, client: Client) {
     super(
       [
@@ -13,15 +24,31 @@ export class IncompatibleClientError extends BaseError {
   }
 }
 
+/**
+ * Represents an error that occurs when an invalid RPC URL is provided. This class extends the `BaseError` class and includes the invalid URL in the error message.
+ */
 export class InvalidRpcUrlError extends BaseError {
   override name = "InvalidRpcUrlError";
+
+  /**
+   * Creates an instance of an error with a message indicating an invalid RPC URL.
+   *
+   * @param {string} [rpcUrl] The invalid RPC URL that caused the error
+   */
   constructor(rpcUrl?: string) {
     super(`Invalid RPC URL ${rpcUrl}`);
   }
 }
 
+/**
+ * Error class representing a "Chain Not Found" error, typically thrown when no chain is supplied to the client.
+ */
 export class ChainNotFoundError extends BaseError {
   override name = "ChainNotFoundError";
+
+  /**
+   * Initializes a new instance of the error message with a default message indicating that no chain was supplied to the client.
+   */
   constructor() {
     super("No chain supplied to the client");
   }

package/src/errors/entrypoint.ts

@@ -1,9 +1,18 @@
 import type { Chain } from "viem";
 import { BaseError } from "./base.js";
 
+/**
+ * Represents an error thrown when an entry point is not found for a specific chain and entry point version. This error indicates that a default entry point does not exist for the given chain and version, and suggests providing an override.
+ */
 export class EntryPointNotFoundError extends BaseError {
   override name = "EntryPointNotFoundError";
 
+  /**
+   * Constructs an error message indicating that no default entry point exists for the given chain and entry point version.
+   *
+   * @param {Chain} chain The blockchain network for which the entry point is being queried
+   * @param {any} entryPointVersion The version of the entry point for which no default exists
+   */
   constructor(chain: Chain, entryPointVersion: any) {
     super(
       [
@@ -14,9 +23,18 @@ export class EntryPointNotFoundError extends BaseError {
   }
 }
 
+/**
+ * Represents an error thrown when an invalid entry point version is encountered for a specific chain. This error extends the `BaseError` class.
+ */
 export class InvalidEntryPointError extends BaseError {
   override name = "InvalidEntryPointError";
 
+  /**
+   * Constructs an error indicating an invalid entry point version for a specific chain.
+   *
+   * @param {Chain} chain The chain object containing information about the blockchain
+   * @param {any} entryPointVersion The entry point version that is invalid
+   */
   constructor(chain: Chain, entryPointVersion: any) {
     super(
       `Invalid entry point: unexpected version ${entryPointVersion} for ${chain.name}.`

package/src/errors/signer.ts

@@ -1,7 +1,16 @@
 import { BaseError } from "./base.js";
 
+/**
+ * Represents an error thrown when an invalid signer type is provided to the SmartAccountSigner.
+ */
 export class InvalidSignerTypeError extends BaseError {
   override name = "InvalidSignerTypeError";
+
+  /**
+   * Constructs an error message when an invalid signer type is passed to SmartAccountSigner.
+   *
+   * @param {string} [signerType] An optional parameter specifying the signer type. If not provided, a default error message will be used.
+   */
   constructor(signerType?: string) {
     super(
       [

package/src/errors/transaction.ts

@@ -1,15 +1,30 @@
 import type { Hex } from "viem";
 import { BaseError } from "./base.js";
 
+/**
+ * Error thrown when a transaction is missing the `to` address parameter. This class extends the `BaseError` class.
+ */
 export class TransactionMissingToParamError extends BaseError {
   override name = "TransactionMissingToParamError";
-  constructor() {
+
+  /**
+   * Throws an error indicating that a transaction is missing the `to` address in the request.
+   */ constructor() {
     super("Transaction is missing `to` address set on request");
   }
 }
 
+/**
+ * Represents an error that occurs when a transaction cannot be found for a given user operation. This error extends from `BaseError`. The `hash` of the transaction is provided to indicate which transaction could not be found.
+ */
 export class FailedToFindTransactionError extends BaseError {
   override name = "FailedToFindTransactionError";
+
+  /**
+   * Constructs a new error message indicating a failure to find the transaction for the specified user operation hash.
+   *
+   * @param {Hex} hash The hexadecimal value representing the user operation hash.
+   */
   constructor(hash: Hex) {
     super(`Failed to find transaction for user operation ${hash}`);
   }

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";
@@ -130,16 +104,12 @@ export type {
   SmartAccountAuthenticator,
   SmartAccountSigner,
 } from "./signer/types.js";
-export {
-  verifyEIP6492Signature,
-  wrapSignatureWith6492,
-} from "./signer/utils.js";
+export { 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,
@@ -156,10 +126,7 @@ export {
   bypassPaymasterAndDataEmptyHex,
   concatPaymasterAndData,
   deepHexlify,
-  defineReadOnly,
   filterUndefined,
-  getChain,
-  getDefaultSimpleAccountFactoryAddress,
   getDefaultUserOperationFeeOptions,
   isBigNumberish,
   isMultiplier,

package/src/logger.ts

@@ -7,42 +7,133 @@ export enum LogLevel {
   NONE = 0,
 }
 
+/**
+ * Logger class provides static methods for logging at different levels such as error, warn, debug, info, and verbose. This class allows setting log levels and log filters to control the logging behavior.
+ */
 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,