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

package/src/signer/local-account.ts

@@ -21,17 +21,67 @@ export class LocalAccountSigner<
   inner: T;
   signerType: string;
 
+  /**
+   * A function to initialize an object with an inner parameter and derive a signerType from it.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { privateKeyToAccount, generatePrivateKey } from "viem";
+   *
+   * const signer = new LocalAccountSigner(
+   *  privateKeyToAccount(generatePrivateKey()),
+   * );
+   * ```
+   *
+   * @param {T} inner The inner parameter containing the necessary data
+   */
   constructor(inner: T) {
     this.inner = inner;
     this.signerType = inner.type; //  type: "local"
   }
 
+  /**
+   * Signs the provided message using the inner signMessage function.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const signature = await signer.signMessage("Hello, world!");
+   * ```
+   *
+   * @param {string} message The message to be signed
+   * @returns {Promise<any>} A promise that resolves to the signed message
+   */
   readonly signMessage: (message: SignableMessage) => Promise<`0x${string}`> = (
     message
   ) => {
     return this.inner.signMessage({ message });
   };
 
+  /**
+   * Signs typed data using the given parameters.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const signature = await signer.signTypedData({
+   *  domain: {},
+   *  types: {},
+   *  primaryType: "",
+   *  message: {},
+   * });
+   * ```
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} params The parameters defining the typed data and primary type
+   * @returns {Promise<Hex>} A promise that resolves to the signed data in hexadecimal format
+   */
   readonly signTypedData = async <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string = string
@@ -41,10 +91,39 @@ export class LocalAccountSigner<
     return this.inner.signTypedData(params);
   };
 
-  readonly getAddress: () => Promise<`0x${string}`> = async () => {
+  /**
+   * Returns the address of the inner object in a specific hexadecimal format.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * const address = await signer.getAddress();
+   * ```
+   *
+   * @returns {Promise<Hex>} A promise that resolves to the address in the format `0x{string}`
+   */
+  readonly getAddress = async (): Promise<`0x${string}`> => {
     return this.inner.address;
   };
 
+  /**
+   * Creates a LocalAccountSigner using the provided mnemonic key and optional HD options.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generateMnemonic } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generateMnemonic());
+   * ```
+   *
+   * @param {string} key The mnemonic key to derive the account from.
+   * @param {HDOptions} [opts] Optional HD options for deriving the account.
+   * @returns {LocalAccountSigner<HDAccount>} A LocalAccountSigner object for the derived account.
+   */
   static mnemonicToAccountSigner(
     key: string,
     opts?: HDOptions
@@ -53,7 +132,20 @@ export class LocalAccountSigner<
     return new LocalAccountSigner(signer);
   }
 
-  static privateKeyToAccountSigner(
+  /**
+   * Creates a `LocalAccountSigner` instance using the provided private key.
+   *
+   * @example
+   * ```ts
+   * import { LocalAccountSigner } from "@aa-sdk/core";
+   * import { generatePrivateKey } from "viem";
+   *
+   * const signer = LocalAccountSigner.mnemonicToAccountSigner(generatePrivateKey());
+   * ```
+   *
+   * @param {Hex} key The private key in hexadecimal format
+   * @returns {LocalAccountSigner<PrivateKeyAccount>} An instance of `LocalAccountSigner` initialized with the provided private key
+   */ static privateKeyToAccountSigner(
     key: Hex
   ): LocalAccountSigner<PrivateKeyAccount> {
     const signer = privateKeyToAccount(key);

package/src/signer/wallet-client.ts

@@ -16,6 +16,27 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
   signerType: string;
   inner: WalletClient;
 
+  /**
+   * Initializes a signer with a given wallet client and signer type.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * ```
+   *
+   * @param {WalletClient} client The wallet client to interact with
+   * @param {string} signerType The type of signer; must be a valid signer type, otherwise an error will be thrown
+   * @throws {InvalidSignerTypeError} If the signer type is invalid
+   */
   constructor(client: WalletClient, signerType: string) {
     this.inner = client;
     if (!signerType) {
@@ -24,11 +45,52 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
     this.signerType = signerType;
   }
 
+  /**
+   * Asynchronously retrieves addresses from the inner object and returns the first address after applying the `getAddress` function.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.getAddress());
+   * ```
+   *
+   * @returns {Promise<string>} A promise that resolves to the first address after being processed by the `getAddress` function.
+   */
   getAddress: () => Promise<`0x${string}`> = async () => {
     let addresses = await this.inner.getAddresses();
     return getAddress(addresses[0]);
   };
 
+  /**
+   * Signs a message using the account's signing method.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.signMessage("hello"));
+   * ```
+   *
+   * @param {string} message the message string that needs to be signed
+   * @returns {Promise<string>} a promise that resolves to the signed message
+   */
   readonly signMessage: (message: SignableMessage) => Promise<`0x${string}`> =
     async (message) => {
       const account = this.inner.account ?? (await this.getAddress());
@@ -36,6 +98,33 @@ export class WalletClientSigner implements SmartAccountSigner<WalletClient> {
       return this.inner.signMessage({ message, account });
     };
 
+  /**
+   * Signs the provided typed data using the account's private key.
+   *
+   * @example
+   * ```ts
+   * import { WalletClientSigner } from "@aa-sdk/core";
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum!)
+   * });
+   *
+   * const signer = new WalletClientSigner(client, 'wallet');
+   * console.log(await signer.signTypedData({
+   *  types: {
+   *    "Message": [{ name: "content", type: "string" }]
+   *  },
+   *  primaryType: "Message",
+   *  message: { content: "Hello" },
+   * }));
+   * ```
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} typedData The typed data to be signed
+   * @returns {Promise<Hex>} A promise that resolves to a hex string representing the signed data
+   */
   signTypedData = async <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string = string

package/src/transport/split.ts

@@ -37,8 +37,8 @@ export interface SplitTransportParams {
  * });
  * ```
  *
- * @param params {@link SplitTransportParams} split transport configuration containing the methods overrides and fallback transport
- * @returns a {@link CustomTransport} that splits traffic
+ * @param {SplitTransportParams} params split transport configuration containing the methods overrides and fallback transport
+ * @returns {CustomTransport} a viem Transport that splits traffic
  */
 export const split = (params: SplitTransportParams): CustomTransport => {
   const overrideMap = params.overrides.reduce((accum, curr) => {

package/src/utils/bigint.ts

@@ -5,8 +5,8 @@ import { isMultiplier } from "./schema.js";
 /**
  * Returns the max bigint in a list of bigints
  *
- * @param args a list of bigints to get the max of
- * @returns the max bigint in the list
+ * @param {bigint[]} args a list of bigints to get the max of
+ * @returns {bigint} the max bigint in the list
  */
 export const bigIntMax = (...args: bigint[]): bigint => {
   if (!args.length) {
@@ -19,8 +19,8 @@ export const bigIntMax = (...args: bigint[]): bigint => {
 /**
  * Returns the min bigint in a list of bigints
  *
- * @param args a list of bigints to get the max of
- * @returns the min bigint in the list
+ * @param {bigint[]} args a list of bigints to get the max of
+ * @returns {bigint} the min bigint in the list
  */
 export const bigIntMin = (...args: bigint[]): bigint => {
   if (!args.length) {
@@ -33,16 +33,16 @@ export const bigIntMin = (...args: bigint[]): bigint => {
 /**
  * Given a bigint and a min-max range, returns the min-max clamped bigint value
  *
- * @param value a bigint value to clamp
- * @param lower lower bound min max tuple value
- * @param upper upper bound min max tuple value
- * @returns the clamped bigint value per given range
+ * @param {BigNumberish} value a bigint value to clamp
+ * @param {BigNumberish | undefined} lower lower bound min max tuple value
+ * @param {BigNumberish | undefined} upper upper bound min max tuple value
+ * @returns {bigint} the clamped bigint value per given range
  */
 export const bigIntClamp = (
   value: BigNumberish,
   lower: BigNumberish | null | undefined,
   upper: BigNumberish | null | undefined
-) => {
+): bigint => {
   lower = lower != null ? BigInt(lower) : null;
   upper = upper != null ? BigInt(upper) : null;
 
@@ -71,10 +71,10 @@ export enum RoundingMode {
  * Given a bigint and a number (which can be a float), returns the bigint value.
  * Note: this function has loss and will round down to the nearest integer.
  *
- * @param base - the number to be multiplied
- * @param multiplier - the amount to multiply by
- * @param roundingMode - the rounding mode to use when calculating the percent. defaults to ROUND_UP
- * @returns the bigint value of the multiplication with the number rounded by the rounding mode
+ * @param {BigNumberish} base - the number to be multiplied
+ * @param {number} multiplier - the amount to multiply by
+ * @param {RoundingMode} roundingMode - the rounding mode to use when calculating the percent. defaults to ROUND_UP
+ * @returns {bigint} the bigint value of the multiplication with the number rounded by the rounding mode
  */
 export const bigIntMultiply = (
   base: BigNumberish,
@@ -111,8 +111,8 @@ export const bigIntMultiply = (
  * });
  * ```
  *
- * @param phrase -- any string value.
- * @returns the bigint value of the hashed string
+ * @param {string} phrase -- any string value.
+ * @returns {bigint} the bigint value of the hashed string
  */
 export const stringToIndex = (phrase: string): bigint =>
   BigInt(keccak256(toHex(phrase)));

package/src/utils/bytes.ts

@@ -8,11 +8,11 @@ type TakeBytesOpts = {
 /**
  * Given a bytes string, returns a slice of the bytes
  *
- * @param bytes - the hex string representing bytes
- * @param opts - optional parameters for slicing the bytes
- * @param opts.offset - the offset in bytes to start slicing from
- * @param opts.count - the number of bytes to slice
- * @returns the sliced bytes
+ * @param {Hex} bytes - the hex string representing bytes
+ * @param {TakeBytesOpts} opts - optional parameters for slicing the bytes
+ * @param {number} opts.offset - the offset in bytes to start slicing from
+ * @param {number} opts.count - the number of bytes to slice
+ * @returns {Hex} the sliced bytes
  */
 export const takeBytes = (bytes: Hex, opts: TakeBytesOpts = {}): Hex => {
   const { offset, count } = opts;

package/src/utils/defaults.ts

@@ -1,79 +1,6 @@
-import { type Address, type Chain } from "viem";
-import {
-  arbitrum,
-  arbitrumGoerli,
-  arbitrumSepolia,
-  base,
-  baseGoerli,
-  baseSepolia,
-  fraxtal,
-  fraxtalSepolia,
-  goerli,
-  mainnet,
-  optimism,
-  optimismGoerli,
-  optimismSepolia,
-  polygon,
-  polygonAmoy,
-  polygonMumbai,
-  sepolia,
-  zora,
-  zoraSepolia,
-} from "../chains/index.js";
-import { defaultEntryPointVersion } from "../entrypoint/index.js";
-import type { EntryPointVersion } from "../entrypoint/types.js";
-import { DefaultFactoryNotDefinedError } from "../errors/account.js";
-import type { UserOperationFeeOptions } from "../types";
-
-/**
- * Utility method returning the default simple account factory address given a {@link Chain} object
- *
- * @param chain - a {@link Chain} object
- * @param version - {@link EntryPointVersion} value that defaults to `defaultEntryPointVersion`
- * @returns a {@link abi.Address} for the given chain
- * @throws if the chain doesn't have an address currently deployed
- */
-export const getDefaultSimpleAccountFactoryAddress = (
-  chain: Chain,
-  version: EntryPointVersion = defaultEntryPointVersion
-): Address => {
-  switch (version) {
-    case "0.6.0":
-      switch (chain.id) {
-        case mainnet.id:
-        case polygon.id:
-        case polygonAmoy.id:
-        case optimism.id:
-        case optimismSepolia.id:
-        case arbitrum.id:
-        case arbitrumSepolia.id:
-        case base.id:
-        case baseGoerli.id:
-        case baseSepolia.id:
-        case fraxtal.id:
-        case fraxtalSepolia.id:
-        case zora.id:
-        case zoraSepolia.id:
-          return "0x15Ba39375ee2Ab563E8873C8390be6f2E2F50232";
-        case sepolia.id:
-        case goerli.id:
-        case polygonMumbai.id:
-        case optimismGoerli.id:
-        case arbitrumGoerli.id:
-          return "0x9406Cc6185a346906296840746125a0E44976454";
-        default:
-          break;
-      }
-      break;
-    case "0.7.0":
-      switch (chain.id) {
-        default:
-          return "0x91E60e0613810449d098b0b5Ec8b51A0FE8c8985";
-      }
-  }
-
-  throw new DefaultFactoryNotDefinedError("SimpleAccount", chain, version);
-};
+import { type Chain } from "viem";
+import { arbitrum, arbitrumGoerli, arbitrumSepolia } from "viem/chains";
+import type { UserOperationFeeOptions } from "../types.js";
 
 export const minPriorityFeePerBidDefaults = new Map<number, bigint>([
   [arbitrum.id, 10_000_000n],

package/src/utils/index.ts

@@ -1,35 +1,12 @@
-import type { Chain } from "viem";
 import { toHex } from "viem";
-import * as chains from "viem/chains";
-import * as alchemyChains from "../chains/index.js";
 import type { PromiseOrValue } from "../types.js";
 import type { RecordableKeys } from "./types.js";
 
-export const AlchemyChainMap = new Map<number, Chain>(
-  Object.values(alchemyChains).map((c) => [c.id, c])
-);
-
-/**
- * Utility method for converting a chainId to a {@link Chain} object
- *
- * @param chainId - the chainId to convert
- * @returns a {@link Chain} object for the given chainId
- * @throws if the chainId is not found
- */
-export const getChain = (chainId: number): Chain => {
-  for (const chain of Object.values(chains)) {
-    if (chain.id === chainId) {
-      return AlchemyChainMap.get(chain.id) ?? chain;
-    }
-  }
-  throw new Error("could not find chain");
-};
-
 /**
  * Utility function that allows for piping a series of async functions together
  *
- * @param fns - functions to pipe
- * @returns result of the pipe
+ * @param {((s: S, o?: O, f?: F) => Promise<S>)[]} fns - functions to pipe
+ * @returns {S} result of the pipe
  */
 export const asyncPipe =
   <S, O, F>(...fns: ((s: S, o?: O, f?: F) => Promise<S>)[]) =>
@@ -47,10 +24,10 @@ export type Deferrable<T> = {
 };
 
 /**
- * Await all of the properties of a {@link Deferrable} object
+ * Await all of the properties of a Deferrable object
  *
- * @param object - a {@link Deferrable} object
- * @returns the object with its properties resolved
+ * @param {Deferrable<T>} object - a Deferrable object
+ * @returns {Promise<T>} the object with its properties resolved
  */
 export async function resolveProperties<T>(object: Deferrable<T>): Promise<T> {
   const promises = Object.keys(object).map((key) => {
@@ -71,8 +48,8 @@ export async function resolveProperties<T>(object: Deferrable<T>): Promise<T> {
 /**
  * Recursively converts all values in an object to hex strings
  *
- * @param obj - obj to deep hexlify
- * @returns object with all of its values hexlified
+ * @param {any} obj - obj to deep hexlify
+ * @returns {any} object with all of its values hexlified
  */
 export function deepHexlify(obj: any): any {
   if (typeof obj === "function") {
@@ -149,8 +126,8 @@ export function pick(obj: Record<string, unknown>, keys: string | string[]) {
 /**
  * Utility method for checking if the passed in values are all equal (strictly)
  *
- * @param params - values to check
- * @returns a boolean indicating if all values are the same
+ * @param {...any[]} params - values to check
+ * @returns {boolean} a boolean indicating if all values are the same
  * @throws if no values are passed in
  */
 export const allEqual = (...params: any[]): boolean => {
@@ -163,9 +140,9 @@ export const allEqual = (...params: any[]): boolean => {
 /**
  * Utility method for checking the condition and return the value if condition holds true, undefined if not.
  *
- * @param condition - condition to check
- * @param value - value to return when condition holds true
- * @returns the value if condition holds true, undefined if not
+ * @param {Promise<boolean>} condition - condition to check
+ * @param {() => Promise<T>} value - value to return when condition holds true
+ * @returns {Promise<T | undefined>} the value if condition holds true, undefined if not
  */
 export const conditionalReturn = <T>(
   condition: Promise<boolean>,

package/src/utils/types.ts

@@ -10,7 +10,7 @@
 export type NoUndefined<T> = T extends undefined ? never : T;
 // borrowed from viem
 /**
- * @description Checks if {@link T} is `undefined`
+ * @description Checks if T is `undefined`
  * @param T - Type to check
  * @example
  * type Result = IsUndefined<undefined>
@@ -27,7 +27,7 @@ export type RequiredBy<TType, TKeys extends keyof TType> = Required<
 /**
  * @description Combines members of an intersection into a readable type.
  *
- * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @see https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
  * @example
  * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
  * => { a: string, b: string, c: number, d: bigint }

package/src/utils/userop.ts

@@ -14,10 +14,10 @@ import { bigIntClamp, bigIntMultiply } from "./bigint.js";
 import { allEqual, isBigNumberish } from "./index.js";
 
 /**
- * Utility method for asserting a {@link UserOperationStruct} has valid fields for the given entry point version
+ * Utility method for asserting a UserOperationStruct has valid fields for the given entry point version
  *
- * @param request a {@link UserOperationStruct} to validate
- * @returns a type guard that asserts the {@link UserOperationRequest} is valid
+ * @param {UserOperationStruct} request a UserOperationStruct to validate
+ * @returns {boolean} a type guard that asserts the UserOperationRequest is valid
  */
 export function isValidRequest<
   TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -37,10 +37,10 @@ export function isValidRequest<
 }
 
 /**
- * Utility method for asserting a {@link UserOperationRequest} has valid fields for the paymaster data
+ * Utility method for asserting a UserOperationRequest has valid fields for the paymaster data
  *
- * @param request a {@link UserOperationRequest} to validate
- * @returns a type guard that asserts the {@link UserOperationRequest} is a {@link UserOperationRequest}
+ * @param {UserOperationRequest} request a UserOperationRequest to validate
+ * @returns {boolean}  a type guard that asserts the UserOperationRequest is a UserOperationRequest
  */
 export function isValidPaymasterAndData<
   TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -59,10 +59,10 @@ export function isValidPaymasterAndData<
 }
 
 /**
- * Utility method for asserting a {@link UserOperationStruct} has valid fields for the paymaster data
+ * Utility method for asserting a UserOperationStruct has valid fields for the paymaster data
  *
- * @param request a {@link UserOperationRequest} to validate
- * @returns a type guard that asserts the {@link UserOperationStruct} is a {@link UserOperationRequest}
+ * @param {UserOperationRequest} request a UserOperationRequest to validate
+ * @returns {boolean} a type guard that asserts the UserOperationStruct is a UserOperationRequest
  */
 export function isValidFactoryAndData<
   TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -80,12 +80,12 @@ export function isValidFactoryAndData<
 }
 
 /**
- * Utility method for applying a {@link UserOperationOverrides} field value
+ * Utility method for applying a UserOperationOverrides field value
  * over the current value set for the field
  *
- * @param value the current value of the field
- * @param override the override value to apply
- * @returns the new value of the field after applying the override
+ * @param {BigNumberish} value the current value of the field
+ * @param {BigNumberish | Multiplier} override the override value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override
  */
 export function applyUserOpOverride<TValue extends BigNumberish | undefined>(
   value: TValue,
@@ -106,12 +106,12 @@ export function applyUserOpOverride<TValue extends BigNumberish | undefined>(
 }
 
 /**
- * Utility method for applying a {@link UserOperationFeeOptionsField} value
+ * Utility method for applying a UserOperationFeeOptionsField value
  * over the current value set for the field
  *
- * @param value the current value of the field
- * @param feeOption the fee option field value to apply
- * @returns the new value of the field after applying the fee option
+ * @param {BigNumberish} value the current value of the field
+ * @param {UserOperationFeeOptionsField} feeOption the override value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override
  */
 export function applyUserOpFeeOption<TValue extends BigNumberish | undefined>(
   value: TValue,
@@ -133,14 +133,14 @@ export function applyUserOpFeeOption<TValue extends BigNumberish | undefined>(
 }
 
 /**
- * Utility method for applying a {@link UserOperationOverrides} field value and
- * a {@link UserOperationFeeOptionsField} value over the current value set for the field,
+ * Utility method for applying a UserOperationOverrides field value and
+ * a UserOperationFeeOptionsField value over the current value set for the field,
  * with the override taking precedence over the fee option
  *
- * @param value the current value of the field
- * @param [override] the override value to apply
- * @param [feeOption] the fee option field value to apply
- * @returns the new value of the field after applying the override or fee option
+ * @param {BigNumberish} value the current value of the field
+ * @param {BigNumberish | Multiplier} [override] the override value to apply
+ * @param {UserOperationFeeOptionsField} [feeOption] the fee option field value to apply
+ * @returns {BigNumberish} the new value of the field after applying the override or fee option
  */
 export function applyUserOpOverrideOrFeeOption<
   TValue extends BigNumberish | undefined
@@ -160,8 +160,8 @@ export function applyUserOpOverrideOrFeeOption<
  * either because the UserOp is paying for its own gas, or passing a specific paymaster
  *
  * @template EntryPointVersion TEntryPointVersion
- * @param overrides the user operation overrides to check
- * @returns whether the paymaster middleware should be bypassed
+ * @param {UserOperationOverrides<TEntryPointVersion> | undefined} overrides the user operation overrides to check
+ * @returns {boolean} whether the paymaster middleware should be bypassed
  */
 export const bypassPaymasterAndData = <
   TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -177,8 +177,8 @@ export const bypassPaymasterAndData = <
  * pay for its own gas
  *
  * @template EntryPointVersion TEntryPointVersion
- * @param overrides the user operation overrides to check
- * @returns whether the paymaster middleware should be bypassed
+ * @param {UserOperationOverrides<TEntryPointVersion> | undefined} overrides the user operation overrides to check
+ * @returns {boolean} whether the paymaster middleware should be bypassed
  */
 export const bypassPaymasterAndDataEmptyHex = <
   TEntryPointVersion extends EntryPointVersion = EntryPointVersion
@@ -192,9 +192,9 @@ export const bypassPaymasterAndDataEmptyHex = <
 /**
  * Utility method for parsing the paymaster address and paymasterData from the paymasterAndData hex string
  *
- * @param paymasterAndData the paymaster and data hex string to parse.
+ * @param {Hex} paymasterAndData the paymaster and data hex string to parse.
  *                         The hex string refers to the paymasterAndData field of entrypoint v0.6 user operation request
- * @returns the parsed paymaster and paymasterData fields of entrypoint v0.7 user operation request paymaster and paymasterData field
+ * @returns {{ paymaster: Hex; paymasterData: Hex}} the parsed paymaster and paymasterData fields of entrypoint v0.7 user operation request paymaster and paymasterData field
  */
 export const parsePaymasterAndData = (
   paymasterAndData: Hex
@@ -207,11 +207,11 @@ export const parsePaymasterAndData = (
  * Utility method for converting the object containing the paymaster address and paymaster data
  * to the paymaster and data concatenated hex string
  *
- * @param paymasterAndData the object containing the picked paymaster and paymasterData fields of
+ * @param {{ paymaster: Hex; paymasterData: Hex}} paymasterAndData the object containing the picked paymaster and paymasterData fields of
  *                         entrypoint v0.7 user operation request
- * @param paymasterAndData.paymaster the paymaster address
- * @param paymasterAndData.paymasterData the paymaster data
- * @returns the paymasterAndData hex value of entrypoint v0.6 user operation request paymasterAndData field
+ * @param {Hex} paymasterAndData.paymaster the paymaster address
+ * @param {Hex} paymasterAndData.paymasterData the paymaster data
+ * @returns {Hex} the paymasterAndData hex value of entrypoint v0.6 user operation request paymasterAndData field
  */
 export const concatPaymasterAndData = ({
   paymaster = "0x",