@aa-sdk/core 4.0.0-alpha.1 → 4.0.0-alpha.11

package/src/actions/smartAccount/internal/sendUserOperation.ts

@@ -15,13 +15,6 @@ import type {
 import { signUserOperation } from "../signUserOperation.js";
 import type { GetContextParameter, UserOperationContext } from "../types";
 
-/**
- * Used internally to send a user operation that has **already** been signed
- *
- * @param client a base smart account client instance with middleware configured
- * @param args user operation struct, overrides, account, and context to be used in sending
- * @returns A Promise containing the send user operation result {@link SendUserOperationResult}
- */
 export async function _sendUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/sendUserOperation.ts

@@ -17,9 +17,23 @@ import type {
 /**
  * Sends a user operation or batch of user operations using the connected account. Before executing, sendUserOperation will run the user operation through the middleware pipeline.
  *
- * @param client the smart account client to use for RPC requests
- * @param args {@link SendUserOperationParameters} containg the UO or batch to send, context, overrides, and account if not hoisted on the client
- * @returns a Promise containing the {@link SendUserOperationResult}
+ * @example
+ * ```ts
+ * import { createSmartAccountClient, toSmartContractAccount } from "@aa-sdk/core";
+ *
+ * const account = await toSmartContractAccount(...);
+ * const result = await createSmartAccountClient(...).sendUserOperation({
+ *  uo: {
+ *    target: "0x...",
+ *    data: "0x...", // or "0x",
+ *    value: 0n, // optional
+ *  }
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the smart account client to use for RPC requests
+ * @param {SendUserOperationParameters<TAccount, TContext>} args contains the UO or batch to send, context, overrides, and account if not hoisted on the client
+ * @returns {Promise<SendUserOperationResult<TEntryPointVersion>>} a Promise containing the result of the user operation
  */
 export async function sendUserOperation<
   TTransport extends Transport = Transport,

package/src/client/bundlerClient.ts

@@ -58,8 +58,8 @@ export const createBundlerClientFromExisting: <
 /**
  * Creates a PublicClient with methods for calling Bundler RPC methods
  *
- * @param args - configuration for the client
- * @returns a PublicClient with methods for calling Bundler RPC methods
+ * @param {PublicClientConfig<TTransport, Chain> & { type?: string }} args - configuration for the client
+ * @returns {BundlerClient<TTransport>} a PublicClient with methods for calling Bundler RPC methods
  */
 export function createBundlerClient<TTransport extends Transport>(
   args: PublicClientConfig<TTransport, Chain> & { type?: string }

package/src/client/decorators/bundlerClient.ts

@@ -55,10 +55,10 @@ export type BundlerActions = {
   /**
    * calls `eth_estimateUserOperationGas` and  returns the result
    *
-   * @param request - the {@link UserOperationRequest} to estimate gas for
+   * @param request - the UserOperationRequest to estimate gas for
    * @param entryPoint - the entry point address the op will be sent to
    * @param stateOverride - the state override to use for the estimation
-   * @returns the gas estimates for the given response (see: {@link UserOperationEstimateGasResponse})
+   * @returns the gas estimates for the given response
    */
   estimateUserOperationGas<
     TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -71,7 +71,7 @@ export type BundlerActions = {
   /**
    * calls `eth_sendUserOperation` and returns the hash of the sent UserOperation
    *
-   * @param request - the {@link UserOperationRequest} to send
+   * @param request - the UserOperationRequest to send
    * @param entryPoint - the entry point address the op will be sent to
    * @returns the hash of the sent UserOperation
    */
@@ -83,25 +83,25 @@ export type BundlerActions = {
   ): Promise<Hash>;
 
   /**
-   * calls `eth_getUserOperationByHash` and returns the {@link UserOperationResponse}
+   * calls `eth_getUserOperationByHash` and returns the UserOperationResponse
    *
    * @param hash - the hash of the UserOperation to fetch
-   * @returns - {@link UserOperationResponse}
+   * @returns - the user operation if found or null
    */
   getUserOperationByHash(hash: Hash): Promise<UserOperationResponse | null>;
 
   /**
-   * calls `eth_getUserOperationReceipt` and returns the {@link UserOperationReceipt}
+   * calls `eth_getUserOperationReceipt` and returns the UserOperationReceipt
    *
    * @param hash - the hash of the UserOperation to get the receipt for
-   * @returns - {@link UserOperationReceipt}
+   * @returns - a user operation receipt or null if not found
    */
   getUserOperationReceipt(hash: Hash): Promise<UserOperationReceipt | null>;
 
   /**
    * calls `eth_supportedEntryPoints` and returns the entry points the RPC supports
    *
-   * @returns - {@link Address}[]
+   * @returns - an array of the entrypoint addresses supported
    */
   getSupportedEntryPoints(): Promise<Address[]>;
 };

package/src/client/isSmartAccountClient.ts

@@ -11,8 +11,8 @@ import type {
  * Useful for narrowing the type of the client down when used within the
  * smart account client decorators
  *
- * @param client a viem client
- * @returns true if the client is a SmartAccountClient
+ * @param {Client<TTransport, TChain, TAccount>} client a viem client
+ * @returns {boolean} true if the client is a SmartAccountClient
  */
 export function isSmartAccountClient<
   TTransport extends Transport = Transport,
@@ -37,8 +37,8 @@ export function isSmartAccountClient<
  * Useful for narrowing the type of the client down when used within the
  * smart account action decorators
  *
- * @param client a viem client
- * @returns true if the account is a BaseSmartAccountClient
+ * @param {Client<TTransport, TChain, TAccount>} client a viem client
+ * @returns {boolean} true if the account is a BaseSmartAccountClient
  */
 export function isBaseSmartAccountClient<
   TTransport extends Transport = Transport,

package/src/client/smartAccountClient.ts

@@ -181,6 +181,13 @@ export function createSmartAccountClient(
       return custom({
         async request({ method, params }) {
           switch (method) {
+            case "eth_accounts": {
+              if (!client.account) {
+                throw new AccountNotFoundError();
+              }
+
+              return [client.account.address];
+            }
             case "eth_sendTransaction":
               if (!client.account) {
                 throw new AccountNotFoundError();

package/src/client/types.ts

@@ -3,10 +3,7 @@ import type { Hash, Hex } from "viem";
 import type { z } from "zod";
 import type { UserOperationContext } from "../actions/smartAccount/types.js";
 import type { EntryPointVersion } from "../entrypoint/types.js";
-import type {
-  ClientMiddleware,
-  ClientMiddlewareFn,
-} from "../middleware/types.js";
+import type { ClientMiddleware } from "../middleware/types.js";
 import type { UserOperationRequest } from "../types.js";
 import type { ConnectionConfigSchema } from "./schema.js";
 
@@ -37,15 +34,5 @@ export type ClientMiddlewareConfig<
   TContext extends UserOperationContext | undefined =
     | UserOperationContext
     | undefined
-> = Omit<
-  Partial<ClientMiddleware<TContext>>,
-  "dummyPaymasterAndData" | "paymasterAndData"
-> & {
-  paymasterAndData?: {
-    dummyPaymasterAndData: () =>
-      | UserOperationRequest<"0.6.0">["paymasterAndData"]
-      | Pick<UserOperationRequest<"0.7.0">, "paymaster" | "paymasterData">;
-    paymasterAndData: ClientMiddlewareFn<TContext>;
-  };
-};
+> = Partial<ClientMiddleware<TContext>>;
 // [!endregion ClientMiddlewareConfig]

package/src/ens/utils.ts

@@ -1,6 +1,5 @@
-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])

package/src/errors/account.ts

@@ -9,7 +9,10 @@ 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.");
   }
 }
@@ -20,6 +23,14 @@ export class AccountNotFoundError extends BaseError {
  */
 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(
       [
@@ -35,7 +46,10 @@ export class DefaultFactoryNotDefinedError extends BaseError {
  */
 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");
   }
 }
@@ -45,6 +59,12 @@ export class GetCounterFactualAddressError extends BaseError {
  */
 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}`);
   }
@@ -55,7 +75,12 @@ export class UpgradesNotSupportedError extends BaseError {
  */
 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`);
   }
 }
@@ -65,6 +90,13 @@ export class SignTransactionNotSupportedError extends 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})`);
   }
@@ -75,6 +107,12 @@ export class FailedToGetStorageSlotError extends BaseError {
  */
 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}`);
   }
@@ -85,6 +123,12 @@ export class BatchExecutionNotSupportedError extends BaseError {
  */
 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`);
   }
@@ -95,6 +139,12 @@ export class AccountRequiresOwnerError extends BaseError {
  */
 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}`);
   }
@@ -105,6 +155,13 @@ export class UpgradeToAndCallNotSupportedError extends BaseError {
  */
 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}`);
   }
@@ -115,7 +172,10 @@ export class IncorrectAccountType extends BaseError {
  */
 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/client.ts

@@ -6,6 +6,14 @@ import { BaseError } from "./base.js";
  */
 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(
       [
@@ -21,6 +29,12 @@ export class IncompatibleClientError extends BaseError {
  */
 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}`);
   }
@@ -31,6 +45,10 @@ export class InvalidRpcUrlError extends BaseError {
  */
 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

@@ -7,6 +7,12 @@ import { BaseError } from "./base.js";
 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(
       [
@@ -23,6 +29,12 @@ export class EntryPointNotFoundError extends BaseError {
 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

@@ -5,6 +5,12 @@ import { BaseError } from "./base.js";
  */
 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

@@ -6,7 +6,10 @@ import { BaseError } from "./base.js";
  */
 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");
   }
 }
@@ -16,6 +19,12 @@ export class TransactionMissingToParamError extends BaseError {
  */
 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";
@@ -136,7 +110,6 @@ export { split, type SplitTransportParams } from "./transport/split.js";
 export type * from "./types.js";
 export type * from "./utils/index.js";
 export {
-  AlchemyChainMap,
   BigNumberishRangeSchema,
   BigNumberishSchema,
   ChainSchema,
@@ -154,8 +127,6 @@ export {
   concatPaymasterAndData,
   deepHexlify,
   filterUndefined,
-  getChain,
-  getDefaultSimpleAccountFactoryAddress,
   getDefaultUserOperationFeeOptions,
   isBigNumberish,
   isMultiplier,

package/src/logger.ts

@@ -14,38 +14,126 @@ 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;