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

package/dist/types/signer/local-account.d.ts

@@ -1,5 +1,8 @@
 import { type HDAccount, type HDOptions, type Hex, type LocalAccount, type PrivateKeyAccount, type SignableMessage, type TypedDataDefinition } from "viem";
 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 declare class LocalAccountSigner<T extends HDAccount | PrivateKeyAccount | LocalAccount> implements SmartAccountSigner<T> {
     inner: T;
     signerType: string;

package/dist/types/signer/local-account.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-account.d.ts","sourceRoot":"","sources":["../../../src/signer/local-account.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,GAAG,EACR,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACzB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD,qBAAa,kBAAkB,CAC7B,CAAC,SAAS,SAAS,GAAG,iBAAiB,GAAG,YAAY,CACtD,YAAW,kBAAkB,CAAC,CAAC,CAAC;IAEhC,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;gBAEP,KAAK,EAAE,CAAC;IAKpB,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAIxE;IAEF,QAAQ,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAKnB,QAAQ,GAAG,CAAC,CAEb;IAEF,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAE/C;IAEF,MAAM,CAAC,uBAAuB,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,SAAS,GACf,kBAAkB,CAAC,SAAS,CAAC;IAKhC,MAAM,CAAC,yBAAyB,CAC9B,GAAG,EAAE,GAAG,GACP,kBAAkB,CAAC,iBAAiB,CAAC;CAIzC"}
+{"version":3,"file":"local-account.d.ts","sourceRoot":"","sources":["../../../src/signer/local-account.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,GAAG,EACR,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACzB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;GAEG;AACH,qBAAa,kBAAkB,CAC7B,CAAC,SAAS,SAAS,GAAG,iBAAiB,GAAG,YAAY,CACtD,YAAW,kBAAkB,CAAC,CAAC,CAAC;IAEhC,KAAK,EAAE,CAAC,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;gBAEP,KAAK,EAAE,CAAC;IAKpB,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAIxE;IAEF,QAAQ,CAAC,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uGAKnB,QAAQ,GAAG,CAAC,CAEb;IAEF,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAE/C;IAEF,MAAM,CAAC,uBAAuB,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,SAAS,GACf,kBAAkB,CAAC,SAAS,CAAC;IAKhC,MAAM,CAAC,yBAAyB,CAC9B,GAAG,EAAE,GAAG,GACP,kBAAkB,CAAC,iBAAiB,CAAC;CAIzC"}

package/dist/types/signer/schema.d.ts

@@ -1,5 +1,19 @@
 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 declare const isSigner: (signer: any) => signer is SmartAccountSigner<any>;
 export declare const SignerSchema: z.ZodType<SmartAccountSigner<any>, z.ZodTypeDef, SmartAccountSigner<any>>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/types/signer/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/signer/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,eAAO,MAAM,QAAQ,WAAY,GAAG,sCAUnC,CAAC;AAEF,eAAO,MAAM,YAAY,2EAAyC,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/signer/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,WAAY,GAAG,sCAUnC,CAAC;AAEF,eAAO,MAAM,YAAY,2EAAyC,CAAC"}

package/dist/types/signer/utils.d.ts

@@ -1,16 +1,28 @@
-import { type Address, type Hash, type Hex, type PublicClient } from "viem";
+import { type Address, type Hash, type Hex } from "viem";
 export type SignWith6492Params = {
     factoryAddress: Address;
     factoryCalldata: Hex;
     signature: Hash;
 };
-type VerifyEIP6492SignatureParams = {
-    signer: Address;
-    hash: Hash;
-    signature: Hash;
-    client: PublicClient;
-};
+/**
+ * Wraps a given signature with additional data following the EIP-6492 standard.
+ *
+ * @example
+ * ```ts
+ * import { wrapSignatureWith6492 } from "@aa-sdk/core";
+ *
+ * const signature = wrapSignatureWith6492({
+ *  factoryAddress: "0x...",
+ *  factoryCalldata: "0x...",
+ *  signature: "0x...",
+ * });
+ * ```
+ *
+ * @param {SignWith6492Params} params The parameters to wrap the signature
+ * @param {Hex} params.factoryAddress The address of the factory
+ * @param {Hex} params.factoryCalldata The calldata for the factory
+ * @param {Hex} params.signature The original signature that needs to be wrapped
+ * @returns {Hash} The wrapped signature
+ */
 export declare const wrapSignatureWith6492: ({ factoryAddress, factoryCalldata, signature, }: SignWith6492Params) => Hash;
-export declare const verifyEIP6492Signature: ({ signer, hash, signature, client, }: VerifyEIP6492SignatureParams) => Promise<boolean>;
-export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/types/signer/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/signer/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,GAAG,EACR,KAAK,YAAY,EAClB,MAAM,MAAM,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,GAAG,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,qBAAqB,oDAI/B,kBAAkB,KAAG,IAgBvB,CAAC;AAMF,eAAO,MAAM,sBAAsB,yCAKhC,4BAA4B,KAAG,QAAQ,OAAO,CAahD,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/signer/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,OAAO,EACZ,KAAK,IAAI,EACT,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,GAAG,CAAC;IACrB,SAAS,EAAE,IAAI,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,oDAI/B,kBAAkB,KAAG,IAgBvB,CAAC"}

package/dist/types/signer/wallet-client.d.ts

@@ -1,5 +1,8 @@
 import { type Hex, type SignableMessage, type TypedDataDefinition, type WalletClient } from "viem";
 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 declare class WalletClientSigner implements SmartAccountSigner<WalletClient> {
     signerType: string;
     inner: WalletClient;

package/dist/types/signer/wallet-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet-client.d.ts","sourceRoot":"","sources":["../../../src/signer/wallet-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAClB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD,qBAAa,kBAAmB,YAAW,kBAAkB,CAAC,YAAY,CAAC;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;gBAER,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM;IAQpD,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAGtC;IAEF,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAKtE;IAEJ,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0GAKV,QAAQ,GAAG,CAAC,CAOb;CACH"}
+{"version":3,"file":"wallet-client.d.ts","sourceRoot":"","sources":["../../../src/signer/wallet-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,eAAe,EAEpB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAClB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,kBAAkB,CAAC,YAAY,CAAC;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,YAAY,CAAC;gBAER,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM;IAQpD,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAGtC;IAEF,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAKtE;IAEJ,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0GAKV,QAAQ,GAAG,CAAC,CAOb;CACH"}

package/dist/types/utils/index.d.ts

@@ -34,8 +34,41 @@ export declare function resolveProperties<T>(object: Deferrable<T>): Promise<T>;
  * @returns object with all of its values hexlified
  */
 export declare function deepHexlify(obj: any): any;
-export declare function defineReadOnly<T, K extends keyof T>(object: T, key: K, value: T[K]): void;
+/**
+ * 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 declare function filterUndefined<T>(obj: T): 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 declare function pick(obj: Record<string, unknown>, keys: string | string[]): {};
 /**
  * Utility method for checking if the passed in values are all equal (strictly)
@@ -53,6 +86,26 @@ export declare const allEqual: (...params: any[]) => boolean;
  * @returns the value if condition holds true, undefined if not
  */
 export declare const conditionalReturn: <T>(condition: Promise<boolean>, value: () => Promise<T>) => Promise<T | 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 declare const toRecord: <T extends { [K in RecordableKeys<T>]: string | number | symbol; }, K_1 extends RecordableKeys<T>, V>(array: T[], selector: K_1, fn: (item: T) => V) => Record<T[K_1], V>;
 export * from "./bigint.js";
 export * from "./bytes.js";

package/dist/types/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAIlC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,eAAO,MAAM,eAAe,oBAE3B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,YAAa,MAAM,KAAG,KAO1C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,iJAQnB,CAAC;AAGJ,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAc5E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAqBzC;AAGD,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EACjD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,GACV,IAAI,CAMN;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAO5C;AAED,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,MAIzE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,cAAe,GAAG,EAAE,KAAG,OAK3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,iBACjB,QAAQ,OAAO,CAAC,oDAEgD,CAAC;AAE9E,eAAO,MAAM,QAAQ,2KAYM,CAAC;AAE5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,mBAAmB,YAAY,CAAC;AAChC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAIlC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,eAAO,MAAM,eAAe,oBAE3B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,YAAa,MAAM,KAAG,KAO1C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,iJAQnB,CAAC;AAGJ,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACrC,CAAC;AAEF;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAc5E;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAqBzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAO5C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,MAIzE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,cAAe,GAAG,EAAE,KAAG,OAK3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,iBACjB,QAAQ,OAAO,CAAC,oDAEgD,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,QAAQ,2KAYM,CAAC;AAE5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,mBAAmB,YAAY,CAAC;AAChC,cAAc,aAAa,CAAC"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "4.0.0-alpha.0";
+export declare const VERSION = "4.0.0-alpha.1";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aa-sdk/core",
   "license": "MIT",
-  "version": "4.0.0-alpha.0",
+  "version": "4.0.0-alpha.1",
   "description": "viem based SDK that enables interactions with ERC-4337 Smart Accounts. ABIs are based off the definitions generated in @account-abstraction/contracts",
   "author": "Alchemy",
   "type": "module",
@@ -66,5 +66,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "bd1788c2bd7f28ba762a06c649f30b544f8bade9"
+  "gitHead": "cb4bf5f8a9aa8fdff1610130821b69ff806e79e6"
 }

package/src/account/simple.ts

@@ -155,6 +155,12 @@ export async function createSimpleSmartAccount<
   config: CreateSimpleAccountParams<TTransport, TSigner, TEntryPointVersion>
 ): Promise<SimpleSmartAccount<TSigner, TEntryPointVersion>>;
 
+/**
+ * Creates a simple smart account using the provided parameters, including chain, entry point, factory address, and additional parameters. This function also ensures that a signer is provided.
+ *
+ * @param {CreateSimpleAccountParams} config The parameters for creating a simple smart account
+ * @returns {Promise<SimpleSmartAccount>} A promise that resolves to a `SimpleSmartAccount` object containing the created account information and methods
+ */
 export async function createSimpleSmartAccount({
   chain,
   entryPoint = getEntryPoint(chain),

package/src/account/smartContractAccount.ts

@@ -74,6 +74,21 @@ export type SmartContractAccountWithSigner<
   getSigner: () => TSigner;
 };
 
+/**
+ * Determines if the given SmartContractAccount has a signer associated with it.
+ *
+ * @example
+ * ```ts
+ * import { toSmartContractAccount } from "@aa-sdk/core";
+ *
+ * const account = await toSmartContractAccount(...);
+ *
+ * console.log(isSmartAccountWithSigner(account)); // false: the base account does not have a publicly accessible signer
+ * ```
+ *
+ * @param {SmartContractAccount} account The account to check.
+ * @returns {boolean} true if the account has a signer, otherwise false.
+ */
 export const isSmartAccountWithSigner = (
   account: SmartContractAccount
 ): account is SmartContractAccountWithSigner => {
@@ -138,6 +153,19 @@ export type ToSmartContractAccountParams<
 } & Omit<CustomSource, "signTransaction" | "address">;
 // [!endregion ToSmartContractAccountParams]
 
+/**
+ * Parses the factory address and factory calldata from the provided account initialization code (initCode).
+ *
+ * @example
+ * ```ts
+ * import { parseFactoryAddressFromAccountInitCode } from "@aa-sdk/core";
+ *
+ * const [address, calldata] = parseFactoryAddressFromAccountInitCode("0xAddressCalldata");
+ * ```
+ *
+ * @param {Hex} initCode The initialization code from which to parse the factory address and calldata
+ * @returns {[Address, Hex]} A tuple containing the parsed factory address and factory calldata
+ */
 export const parseFactoryAddressFromAccountInitCode = (
   initCode: Hex
 ): [Address, Hex] => {
@@ -146,6 +174,27 @@ export const parseFactoryAddressFromAccountInitCode = (
   return [factoryAddress, factoryCalldata];
 };
 
+/**
+ * Retrieves the account address. Uses a provided `accountAddress` if available; otherwise, it computes the address using the entry point contract and the initial code.
+ *
+ * @example
+ * ```ts
+ * import { getEntryPoint, getAccountAddress } from "@aa-sdk/core";
+ *
+ * const accountAddress = await getAccountAddress({
+ *  client,
+ *  entryPoint: getEntryPoint(chain),
+ *  getAccountInitCode: async () => "0x{factoryAddress}{factoryCallData}",
+ * });
+ * ```
+ *
+ * @param {object} config The configuration object
+ * @param {PublicClient} config.client A public client instance to interact with the blockchain
+ * @param {EntryPointDef} config.entryPoint The entry point definition which includes the address and ABI
+ * @param {Address} config.accountAddress Optional existing account address
+ * @param {function(): Promise<Hex>} config.getAccountInitCode A function that returns a Promise resolving to a Hex string representing the initial code of the account
+ * @returns {Promise<Address>} A promise that resolves to the account address
+ */
 export const getAccountAddress = async ({
   client,
   entryPoint,
@@ -220,21 +269,77 @@ export async function toSmartContractAccount<
 >): Promise<SmartContractAccount<Name, TEntryPointVersion>>;
 // [!endregion toSmartContractAccount]
 
-export async function toSmartContractAccount({
-  transport,
-  chain,
-  entryPoint,
-  source,
-  accountAddress,
-  getAccountInitCode,
-  signMessage,
-  signTypedData,
-  encodeBatchExecute,
-  encodeExecute,
-  getDummySignature,
-  signUserOperationHash,
-  encodeUpgradeToAndCall,
-}: ToSmartContractAccountParams): Promise<SmartContractAccount> {
+/**
+ * Converts an account to a smart contract account and sets up various account-related methods using the provided parameters like transport, chain, entry point, and other utilities.
+ *
+ * @example
+ * ```ts
+ * import { http, type SignableMessage } from "viem";
+ * import { sepolia } from "viem/chains";
+ *
+ * const myAccount = await toSmartContractAccount({
+ *  /// REQUIRED PARAMS ///
+ *  source: "MyAccount",
+ *  transport: http("RPC_URL"),
+ *  chain: sepolia,
+ *  // The EntryPointDef that your account is com"patible with
+ *  entryPoint: getEntryPoint(sepolia, { version: "0.6.0" }),
+ *  // This should return a concatenation of your `factoryAddress` and the `callData` for your factory's create account method
+ *  getAccountInitCode: async () => "0x{factoryAddress}{callData}",
+ *  // an invalid signature that doesn't cause your account to revert during validation
+ *  getDummySignature: () => "0x1234...",
+ *  // given a UO in the form of {target, data, value} should output the calldata for calling your contract's execution method
+ *  encodeExecute: async (uo) => "0xcalldata",
+ *  signMessage: async ({ message }: { message: SignableMessage }) => "0x...",
+ *  signTypedData: async (typedData) => "0x000",
+ *
+ *  /// OPTIONAL PARAMS ///
+ *  // if you already know your account's address, pass that in here to avoid generating a new counterfactual
+ *  accountAddress: "0xaddressoverride",
+ *  // if your account supports batching, this should take an array of UOs and return the calldata for calling your contract's batchExecute method
+ *  encodeBatchExecute: async (uos) => "0x...",
+ *  // if your contract expects a different signing scheme than the default signMessage scheme, you can override that here
+ *  signUserOperationHash: async (hash) => "0x...",
+ *  // allows you to define the calldata for upgrading your account
+ *  encodeUpgradeToAndCall: async (params) => "0x...",
+ * });
+ * ```
+ *
+ * @param {ToSmartContractAccountParams} params the parameters required for converting to a smart contract account
+ * @param {Transport} params.transport the transport mechanism used for communication
+ * @param {Chain} params.chain the blockchain chain used in the account
+ * @param {EntryPoint} params.entryPoint the entry point of the smart contract
+ * @param {string} params.source the source identifier for the account
+ * @param {Address} [params.accountAddress] the address of the account
+ * @param {() => Promise<Hex>} params.getAccountInitCode a function to get the initial state code of the account
+ * @param {(message: { message: SignableMessage }) => Promise<Hex>} params.signMessage a function to sign a message
+ * @param {(typedDataDefinition: TypedDataDefinition<typedData, primaryType>) => Promise<Hex>} params.signTypedData a function to sign typed data
+ * @param {(transactions: Transaction[]) => Hex} [params.encodeBatchExecute] a function to encode batch transactions
+ * @param {(tx: Transaction) => Hex} params.encodeExecute a function to encode a single transaction
+ * @param {() => Promise<Hex>} params.getDummySignature a function to get a dummy signature
+ * @param {(uoHash: Hex) => Promise<Hex>} [params.signUserOperationHash] a function to sign user operations
+ * @param {(implementationAddress: Address, implementationCallData: Hex) => Hex} [params.encodeUpgradeToAndCall] a function to encode upgrade call
+ * @returns {Promise<SmartContractAccount>} a promise that resolves to a SmartContractAccount object with methods and properties for interacting with the smart contract account
+ */
+export async function toSmartContractAccount(
+  params: ToSmartContractAccountParams
+): Promise<SmartContractAccount> {
+  const {
+    transport,
+    chain,
+    entryPoint,
+    source,
+    accountAddress,
+    getAccountInitCode,
+    signMessage,
+    signTypedData,
+    encodeBatchExecute,
+    encodeExecute,
+    getDummySignature,
+    signUserOperationHash,
+    encodeUpgradeToAndCall,
+  } = params;
+
   const client = createBundlerClient({
     // we set the retry count to 0 so that viem doesn't retry during
     // getting the address. That call always reverts and without this

package/src/actions/smartAccount/buildUserOperation.ts

@@ -14,6 +14,29 @@ import type {
   UserOperationContext,
 } from "./types";
 
+/**
+ * Builds a user operation using the provided client and operation parameters. Ensures that the account exists and the client is compatible.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with buildUserOperation
+ * const client = createSmartAccountClient(...);
+ * const result = await client.buildUserOperation({
+ *  uo: {
+ *    target: "0x...",
+ *    data: "0x...", // or "0x",
+ *    value: 0n, // optional
+ *  },
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the client instance used to build the user operation
+ * @param {BuildUserOperationParameters<TAccount, TContext, TEntryPointVersion>} args the parameters required to build the user operation, including account, overrides, and context
+ * @returns {Promise<UserOperationStruct<TEntryPointVersion>>} a promise that resolves to a `UserOperationStruct` object containing the built user operation details
+ */
 export async function buildUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/dropAndReplaceUserOperation.ts

@@ -20,6 +20,28 @@ import type {
   UserOperationContext,
 } from "./types";
 
+/**
+ * Drops an existing user operation and replaces it with a new one while ensuring the appropriate fees and overrides are applied.
+ *
+ * @example
+ * ```ts
+ * import {
+ *  createSmartAccountClient,
+ * } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with dropAndReplaceUserOperation
+ * const client = createSmartAccountClient(...);
+ * const { request } = await client.sendUserOperation(...);
+ * const result = await client.dropAndReplaceUserOperation({
+ *  uoToDrop: request,
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance with the transport, chain, and account information
+ * @param {DropAndReplaceUserOperationParameters<TAccount, TContext>} args The parameters required for dropping and replacing the user operation including the account, operation to drop, overrides, and context
+ * @returns {Promise<SendUserOperationResult<TEntryPointVersion>>} A promise that resolves to the result of sending the new user operation
+ */
 export async function dropAndReplaceUserOperation<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/sendTransaction.ts

@@ -20,6 +20,30 @@ import { _sendUserOperation } from "./internal/sendUserOperation.js";
 import type { UserOperationContext } from "./types.js";
 import { waitForUserOperationTransaction } from "./waitForUserOperationTransacation.js";
 
+/**
+ * Sends a transaction using the provided client, arguments, optional overrides, and context.
+ * This sends a UO and then waits for it to be mined
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with sendTransaction
+ * const client = createSmartAccountClient(...);
+ * const result = await client.sendTransaction({
+ *  to: "0x...",
+ *  data: "0x...", // or "0x",
+ *  value: 0n, // optional
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<Transport, TChain, TAccount>} client The client to send the transaction through
+ * @param {SendTransactionParameters<TChain, TAccount, TChainOverride>} args The parameters required to send the transaction
+ * @param {UserOperationOverrides<TEntryPointVersion>} [overrides] Optional overrides for the user operation
+ * @param {UserOperationContext} [context] Optional context for the user operation
+ * @returns {Promise<Hex>} A promise that resolves to a hex string representing the transaction hash
+ */
 export async function sendTransaction<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends SmartContractAccount | undefined =

package/src/actions/smartAccount/sendTransactions.ts

@@ -9,6 +9,29 @@ import { _sendUserOperation } from "./internal/sendUserOperation.js";
 import type { SendTransactionsParameters, UserOperationContext } from "./types";
 import { waitForUserOperationTransaction } from "./waitForUserOperationTransacation.js";
 
+/**
+ * Sends transactions using the provided client and transaction parameters. This function builds user operations from the transactions, sends them, and waits for the transaction to be mined.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with sendTransactions
+ * const client = createSmartAccountClient(...);
+ * const result = await client.sendTransactions({
+ *  requests: [{
+ *    to: "0x...",
+ *    data: "0x...", // or "0x",
+ *    value: 0n, // optional
+ *  }],
+ *  account, // only required if the client above is not connected to an account
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client used to send the transactions
+ * @param {SendTransactionsParameters<TAccount, TContext>} args The parameters for sending the transactions, including requests, overrides, account, and context
+ * @returns {Promise<Hex>} A promise that resolves to the transaction hash of the sent transactions
+ */
 export async function sendTransactions<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/actions/smartAccount/waitForUserOperationTransacation.ts

@@ -6,6 +6,30 @@ import { FailedToFindTransactionError } from "../../errors/transaction.js";
 import { Logger } from "../../logger.js";
 import type { WaitForUserOperationTxParameters } from "./types.js";
 
+/**
+ * Waits for a user operation transaction to be confirmed by checking the receipt periodically until it is found or a maximum number of retries is reached.
+ *
+ * @example
+ * ```ts
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * // smart account client is already extended with waitForUserOperationTransaction
+ * const client = createSmartAccountClient(...);
+ * const result = await client.waitForUserOperationTransaction({
+ *  hash: "0x...",
+ *  retries: {...} // optional param to configure the retry amounts
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, any>} client The client instance used to interact with the blockchain
+ * @param {WaitForUserOperationTxParameters} args The parameters for the transaction to wait for
+ * @param {Hex} args.hash The transaction hash to wait for
+ * @param {WaitForUserOperationTxParameters["retries"]} [args.retries] Optional retry parameters
+ * @param {number} [args.retries.maxRetries] The maximum number of retry attempts
+ * @param {number} [args.retries.intervalMs] The interval in milliseconds between retries
+ * @param {number} [args.retries.multiplier] The multiplier for the interval between retries
+ * @returns {Promise<Hex>} A promise that resolves to the transaction hash when the transaction is confirmed
+ */
 export const waitForUserOperationTransaction: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined

package/src/client/bundlerClient.ts

@@ -29,6 +29,21 @@ export type BundlerClient<T extends Transport = Transport> = Client<
   PublicActions<T, Chain> & BundlerActions
 >;
 
+/**
+ * Creates a bundler client from an existing public client with the provided transport and chain.
+ *
+ * @example
+ * ```ts
+ * import { createPublicClient } from "viem";
+ * import { createBundlerClientFromExisting } from "@aa-sdk/core";
+ *
+ * const publicClient = createPublicClient(...);
+ * const bundlerClient = createBundlerClientFromExisting(publicClient);
+ * ```
+ *
+ * @param {PublicClient<T, Chain>} client The existing public client to be extended with bundler actions
+ * @returns {BundlerClient<T>} A bundler client that extends the functionality of the provided public client
+ */
 export const createBundlerClientFromExisting: <
   T extends Transport | FallbackTransport = Transport
 >(
@@ -50,6 +65,23 @@ export function createBundlerClient<TTransport extends Transport>(
   args: PublicClientConfig<TTransport, Chain> & { type?: string }
 ): BundlerClient<TTransport>;
 
+/**
+ * Creates a Bundler Client using the provided configuration parameters, including chain and optional type.
+ *
+ * @example
+ * ```ts
+ * import { createBundlerClient } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ *
+ * const client = createBundlerClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ * });
+ * ```
+ *
+ * @param {PublicClientConfig & { type?: string }} args Configuration for creating the Bundler Client, including parameters for the chain, transport, and optional type
+ * @returns {BundlerClient} The created Bundler Client with extended public and bundler actions
+ */
 export function createBundlerClient(
   args: PublicClientConfig & { type?: string }
 ): BundlerClient {

package/src/client/decorators/bundlerClient.ts

@@ -107,6 +107,15 @@ export type BundlerActions = {
 };
 // [!endregion BundlerActions]
 
+/**
+ * A viem client decorator that provides Bundler specific actions.
+ * These actions include estimating gas for user operations, sending raw user operations, retrieving user operations by hash, getting supported entry points, and getting user operation receipts.
+ *
+ * NOTE: this is already added to the client returned from `createBundlerClient`
+ *
+ * @param {TClient} client The client instance that will be used to perform bundler actions
+ * @returns {BundlerActions} An object containing various bundler-related actions that can be executed using the provided client
+ */
 export const bundlerActions: <
   TClient extends Client<
     Transport,

package/src/client/decorators/smartAccountClient.ts

@@ -133,6 +133,14 @@ export type BaseSmartAccountClientActions<
     });
 // #endregion SmartAccountClientActions
 
+/**
+ * Provides a set of smart account client actions to decorate the provided client. These actions include building and signing user operations, sending transactions, and more.
+ *
+ * NOTE: this is already added to clients returned from `createSmartAccountClient`
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client to bind the smart account actions to
+ * @returns {BaseSmartAccountClientActions<TChain, TAccount, TContext>} An object containing various smart account client actions
+ */
 export const smartAccountClientActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,