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

package/src/signer/wallet-client.ts

@@ -9,10 +9,34 @@ import {
 import { InvalidSignerTypeError } from "../errors/signer.js";
 import type { SmartAccountSigner } from "./types";
 
+/**
+ * Represents a wallet client signer for smart accounts, providing methods to get the address, sign messages, and sign typed data.
+ */
 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) {
@@ -21,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());
@@ -33,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") {
@@ -97,19 +74,23 @@ export function deepHexlify(obj: any): any {
   );
 }
 
-// borrowed from ethers.js
-export function defineReadOnly<T, K extends keyof T>(
-  object: T,
-  key: K,
-  value: T[K]
-): void {
-  Object.defineProperty(object, key, {
-    enumerable: true,
-    value: value,
-    writable: false,
-  });
-}
-
+/**
+ * Filters out properties with undefined or null values from the provided object.
+ *
+ * @example
+ * ```ts
+ * import { filterUndefined } from "@aa-sdk/core";
+ *
+ * const result = filterUndefined({
+ *  foo: undefined,
+ *  bar: null,
+ *  baz: "baz",
+ * }); // { baz: "baz" }
+ * ```
+ *
+ * @param {T} obj the object from which to remove properties with undefined or null values
+ * @returns {T} the object with undefined or null properties removed
+ */
 export function filterUndefined<T>(obj: T): T {
   for (const key in obj) {
     if (obj[key] == null) {
@@ -119,6 +100,23 @@ export function filterUndefined<T>(obj: T): T {
   return obj as T;
 }
 
+/**
+ * Picks the specified keys from an object and returns a new object containing only those key-value pairs.
+ *
+ * @example
+ * ```ts
+ * import { pick } from "@aa-sdk/core";
+ *
+ * const picked = pick({
+ *  foo: "foo",
+ *  bar: "bar",
+ * }, ["foo"]); // { foo: "foo" }
+ * ```
+ *
+ * @param {Record<string, unknown>} obj The object from which to pick keys
+ * @param {string|string[]} keys A single key or an array of keys to pick from the object
+ * @returns {Record<string, unknown>} A new object containing only the picked key-value pairs
+ */
 export function pick(obj: Record<string, unknown>, keys: string | string[]) {
   return Object.keys(obj)
     .filter((k) => keys.includes(k))
@@ -128,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 => {
@@ -142,15 +140,35 @@ 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>,
   value: () => Promise<T>
 ): Promise<T | undefined> => condition.then((t) => (t ? value() : undefined));
 
+/**
+ * Converts an array of objects into a record (object) where each key is determined by the specified selector and the value is determined by the provided function.
+ *
+ * @example
+ * ```ts
+ * import { toRecord } from "@aa-sdk/core";
+ * import { sepolia, mainnet } from "viem/chains";
+ *
+ * const addressesByChain = toRecord(
+ *  [sepolia, mainnet],
+ *  "id",
+ *  () => "0x..."
+ * ); // { [sepolia.id]: "0x...", [mainnet.id]: "0x..." }
+ * ```
+ *
+ * @param {T[]} array The array of objects to convert to a record
+ * @param {K} selector The key used to select the property that will become the record's key
+ * @param {(item: T) => V} fn The function that transforms each item in the array into the record's value
+ * @returns {Record<T[K], V>} The resulting record object
+ */
 export const toRecord = <
   T extends { [K in RecordableKeys<T>]: string | number | symbol },
   K extends RecordableKeys<T>,

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",

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "4.0.0-alpha.0";
+export const VERSION = "4.0.0-alpha.9";