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

package/src/client/smartAccountClient.ts

@@ -135,6 +135,26 @@ export function createSmartAccountClient<
   config: SmartAccountClientConfig<TTransport, TChain, TAccount, TContext>
 ): SmartAccountClient<TTransport, TChain, TAccount>;
 
+/**
+ * Creates a smart account client using the provided configuration. This client handles various Ethereum transactions and message signing operations.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient, toSmartContractAccount } from "@aa-sdk/core";
+ * import { http } from "viem";
+ * import { sepolia } from "viem/chains";
+ *
+ * const client = createSmartAccountClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  // optionally hoist the account
+ *  account: toSmartContractAccount(...),
+ * });
+ * ```
+ *
+ * @param {SmartAccountClientConfig} config The configuration for creating the smart account client
+ * @returns {SmartAccountClient} A smart account client capable of handling transactions, message signing, and other operations on a smart account
+ */
 export function createSmartAccountClient(
   config: SmartAccountClientConfig
 ): SmartAccountClient {
@@ -263,6 +283,27 @@ export function createSmartAccountClientFromExisting<
   TContext
 >;
 
+/**
+ * Creates a smart account client using an existing client and specific configuration. This function can be used to reuse a pre-existing BundlerClient while customizing other aspects of the smart account.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   createBundlerClient,
+ *   createSmartAccountClientFromExisting,
+ *   toSmartContractAccount
+ * } from "@aa-sdk/core";
+ *
+ * const bundlerClient = createBundlerClient(...);
+ * const client = createSmartAccountClientFromExisting({
+ *  client,
+ *  account: toSmartContractAccount(...),
+ * })
+ * ```
+ *
+ * @param {Omit<SmartAccountClientConfig, "transport" | "chain"> & {client: BundlerClient}} config the configuration object which includes the client
+ * @returns {SmartAccountClient} A smart account client created from the existing BundlerClient
+ */
 export function createSmartAccountClientFromExisting(
   config: Omit<SmartAccountClientConfig, "transport" | "chain"> & {
     client: BundlerClient;

package/src/ens/utils.ts

@@ -1,11 +1,24 @@
-import type { Chain } from "viem/chains";
 import * as chains from "viem/chains";
-import { mainnet } from "../chains/index.js";
+import { mainnet, type Chain } from "viem/chains";
 
 export const ChainsById: Map<number, chains.Chain> = new Map(
   Object.values(chains).map((x) => [x.id, x])
 );
 
+/**
+ * Converts a given chain ID to a coin type, following specific standards for mainnet and non-mainnet chains.
+ *
+ * @example
+ * ```ts
+ * import { convertChainIdToCoinType } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ *
+ * const coinType = convertChainIdToCoinType(sepolia.id);
+ * ```
+ *
+ * @param {number} chainId the blockchain chain ID that you want to convert to a coin type
+ * @returns {number} the corresponding coin type for the given chain ID
+ */
 export const convertChainIdToCoinType = (chainId: number): number => {
   if (chainId === mainnet.id) {
     // this comes from [ensip-9](https://docs.ens.domains/ens-improvement-proposals/ensip-9-multichain-address-resolution)
@@ -16,6 +29,21 @@ export const convertChainIdToCoinType = (chainId: number): number => {
   return (0x80000000 | chainId) >>> 0;
 };
 
+/**
+ * Converts a coin type to a chain ID based on predefined mappings. This function follows ENSIP-9 for coin type 60 and ENSIP-11 for other coin types.
+ *
+ * @example
+ * ```ts
+ * import { convertChainIdToCoinType, convertCoinTypeToChainId } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ *
+ * const coinType = convertChainIdToCoinType(sepolia.id);
+ * const chainId = convertCoinTypeToChainId(coinType);
+ * ```
+ *
+ * @param {number} coinType the coin type to be converted to a chain ID
+ * @returns {number} the corresponding chain ID
+ */
 export const convertCoinTypeToChainId = (coinType: number): number => {
   if (coinType === 60) {
     // this comes from [ensip-9](https://docs.ens.domains/ens-improvement-proposals/ensip-9-multichain-address-resolution)
@@ -26,6 +54,22 @@ export const convertCoinTypeToChainId = (coinType: number): number => {
   return (0x7fffffff & coinType) >> 0;
 };
 
+/**
+ * Converts a coin type to its corresponding blockchain chain based on a predefined mapping.
+ *
+ * @example
+ * ```ts
+ * import { convertChainIdToCoinType, convertCoinTypeToChain } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ *
+ * const coinType = convertChainIdToCoinType(sepolia.id);
+ * const chain = convertCoinTypeToChain(coinType);
+ * ```
+ *
+ * @param {number} coinType The numerical identifier for the coin type
+ * @returns {Chain} The corresponding blockchain chain
+ * @throws {Error} If the coin type does not map to a supported chain
+ */
 export const convertCoinTypeToChain = (coinType: number): Chain => {
   const chainId = convertCoinTypeToChainId(coinType);
   const chain = ChainsById.get(chainId);

package/src/entrypoint/index.ts

@@ -17,6 +17,20 @@ export const entryPointRegistry: EntryPointRegistry = {
   "0.7.0": EntryPoint_v7,
 };
 
+/**
+ * Checks if the given value is a valid key of the EntryPointRegistry.
+ *
+ * @example
+ * ```ts
+ * import { isEntryPointVersion } from "@aa-sdk/core";
+ *
+ * const valid = isEntryPointVersion("0.6.0");
+ * const invalid = isEntryPointVersion("0.8.0");
+ * ```
+ *
+ * @param {*} value The value to be checked
+ * @returns {boolean} true if the value is a valid key of EntryPointRegistry, false otherwise
+ */
 export const isEntryPointVersion = (
   value: any
 ): value is keyof EntryPointRegistry => {
@@ -44,6 +58,22 @@ export function getEntryPoint<TChain extends Chain = Chain>(
   options?: GetEntryPointOptions<DefaultEntryPointVersion>
 ): EntryPointDefRegistry<TChain>[DefaultEntryPointVersion];
 
+/**
+ * Retrieves the entry point definition for the specified chain and version, falling back to the default version if not provided. Throws an error if the entry point address cannot be found.
+ *
+ * @example
+ * ```ts
+ * import { getEntryPoint } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ *
+ * const entryPoint060 = getEntryPoint(sepolia);
+ * const entryPoint070 = getEntryPoint(sepolia, { version: "0.7.0" });
+ * ```
+ *
+ * @param {Chain} chain The chain for which the entry point is being retrieved
+ * @param {GetEntryPointOptions<TEntryPointVersion>} options Options containing the version and address overrides for the entry point
+ * @returns {EntryPointDefRegistry<TChain>[EntryPointVersion]} The entry point definition for the specified chain and version
+ */
 export function getEntryPoint<
   TEntryPointVersion extends EntryPointVersion,
   TChain extends Chain = Chain
@@ -88,65 +118,3 @@ export function getEntryPoint<
 
   throw new EntryPointNotFoundError(chain, version);
 }
-
-// // =================================================================================
-// // TODO: Add tests for the following cases
-
-// const chain: Chain = mainnet;
-
-// // 1. left and right hand side version type should match, as well as the param
-
-// // === Error ===
-// const ep1_a: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
-//   version: "0.7.0",
-// }); // error
-// const ep1_b: EntryPointDef<"0.7.0"> = getEntryPoint(chain); // error
-// const ep1_c: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
-//   version: "0.7.0",
-// }); // error
-// const ep1_d: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
-//   version: "0.7.0",
-// }); // error
-
-// // === Valid ===
-// const ep1a: EntryPointDef<"0.6.0"> = getEntryPoint(chain);
-// const ep1b: EntryPointDef<"0.6.0"> = getEntryPoint(chain, { version: "0.6.0" });
-// const ep1c: EntryPointDef<"0.7.0"> = getEntryPoint(chain, { version: "0.7.0" });
-// const ep1d: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-// });
-// const ep1e: EntryPointDef<"0.6.0"> = getEntryPoint(chain, {
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-//   version: "0.6.0",
-// });
-// const ep1f: EntryPointDef<"0.7.0"> = getEntryPoint(chain, {
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-//   version: "0.7.0",
-// });
-
-// // 2. If non-default type is specified, version option param of the type is required
-
-// // === Error ===
-// const ep2_a: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain); // error
-// const ep2_b: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-// });
-
-// // === Valid ===
-// const ep2a: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
-//   version: "0.7.0",
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-// });
-// const ep2b: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
-//   version: "0.6.0",
-// });
-// const ep2c: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain);
-// const ep2d: EntryPointDef<"0.6.0"> = getEntryPoint<"0.6.0">(chain, {
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-// });
-// const ep2e: EntryPointDef<"0.7.0"> = getEntryPoint<"0.7.0">(chain, {
-//   version: "0.7.0",
-//   addressOverride: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-// });
-
-// // =================================================================================

package/src/errors/account.ts

@@ -2,6 +2,9 @@ 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";
 
@@ -11,6 +14,10 @@ export class AccountNotFoundError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(accountType: string, chain: Chain, version: EntryPointVersion) {
@@ -23,6 +30,9 @@ 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() {
@@ -30,6 +40,9 @@ export class GetCounterFactualAddressError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(accountType: string) {
@@ -37,6 +50,9 @@ export class UpgradesNotSupportedError extends BaseError {
   }
 }
 
+/**
+ * Error thrown when attempting to sign a transaction that is not supported by smart contracts.
+ */
 export class SignTransactionNotSupportedError extends BaseError {
   override name = "SignTransactionNotSupported";
   constructor() {
@@ -44,6 +60,9 @@ export class SignTransactionNotSupportedError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(slot: string, slotDescriptor: string) {
@@ -51,6 +70,9 @@ export class FailedToGetStorageSlotError extends BaseError {
   }
 }
 
+/**
+ * Represents an error indicating that batch execution is not supported for a specific account type.
+ */
 export class BatchExecutionNotSupportedError extends BaseError {
   override name = "BatchExecutionNotSupportedError";
   constructor(accountType: string) {
@@ -58,6 +80,9 @@ export class BatchExecutionNotSupportedError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(accountType: string) {
@@ -65,6 +90,9 @@ export class AccountRequiresOwnerError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(accountType: string) {
@@ -72,6 +100,9 @@ export class UpgradeToAndCallNotSupportedError extends BaseError {
   }
 }
 
+/**
+ * Represents an error thrown when an account type does not match the expected type.
+ */
 export class IncorrectAccountType extends BaseError {
   override name = "IncorrectAccountTypeError";
   constructor(expected: string, actual: string) {
@@ -79,6 +110,9 @@ export class IncorrectAccountType extends BaseError {
   }
 }
 
+/**
+ * Error class indicating that a smart account operation requires a signer.
+ */
 export class SmartAccountWithSignerRequiredError extends BaseError {
   override name = "SmartAccountWithSignerRequiredError";
   constructor() {

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,6 +1,9 @@
 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";
   constructor(expectedClient: string, method: string, client: Client) {
@@ -13,6 +16,9 @@ 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";
   constructor(rpcUrl?: string) {
@@ -20,6 +26,9 @@ export class InvalidRpcUrlError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor() {

package/src/errors/entrypoint.ts

@@ -1,6 +1,9 @@
 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";
 
@@ -14,6 +17,9 @@ 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";
 

package/src/errors/signer.ts

@@ -1,5 +1,8 @@
 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";
   constructor(signerType?: string) {

package/src/errors/transaction.ts

@@ -1,6 +1,9 @@
 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() {
@@ -8,6 +11,9 @@ export class TransactionMissingToParamError extends BaseError {
   }
 }
 
+/**
+ * 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";
   constructor(hash: Hex) {

package/src/index.ts

@@ -31,27 +31,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,
@@ -130,16 +109,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,9 +131,7 @@ export {
   bypassPaymasterAndDataEmptyHex,
   concatPaymasterAndData,
   deepHexlify,
-  defineReadOnly,
   filterUndefined,
-  getChain,
   getDefaultSimpleAccountFactoryAddress,
   getDefaultUserOperationFeeOptions,
   isBigNumberish,

package/src/logger.ts

@@ -7,6 +7,9 @@ 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;

package/src/middleware/defaults/feeEstimator.ts

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

package/src/middleware/defaults/paymasterAndData.ts

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

package/src/middleware/defaults/userOpSigner.ts

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

package/src/signer/local-account.ts

@@ -11,6 +11,9 @@ import {
 import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
 import type { SmartAccountSigner } from "./types.js";
 
+/**
+ * Represents a local account signer and provides methods to sign messages and transactions, as well as static methods to create the signer from mnemonic or private key.
+ */
 export class LocalAccountSigner<
   T extends HDAccount | PrivateKeyAccount | LocalAccount
 > implements SmartAccountSigner<T>

package/src/signer/schema.ts

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