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

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;
@@ -33,13 +36,13 @@ export declare class WalletClientSigner implements SmartAccountSigner<WalletClie
         [x: `bytes9[${string}]`]: undefined;
         [x: `bytes10[${string}]`]: undefined;
         [x: `bytes25[${string}]`]: undefined;
-        [x: `bytes18[${string}]`]: undefined;
         [x: `bytes12[${string}]`]: undefined;
         [x: `bytes13[${string}]`]: undefined;
         [x: `bytes14[${string}]`]: undefined;
         [x: `bytes15[${string}]`]: undefined;
         [x: `bytes16[${string}]`]: undefined;
         [x: `bytes17[${string}]`]: undefined;
+        [x: `bytes18[${string}]`]: undefined;
         [x: `bytes19[${string}]`]: undefined;
         [x: `bytes20[${string}]`]: undefined;
         [x: `bytes21[${string}]`]: undefined;
@@ -135,13 +138,13 @@ export declare class WalletClientSigner implements SmartAccountSigner<WalletClie
         bytes9?: undefined;
         bytes10?: undefined;
         bytes25?: undefined;
-        bytes18?: undefined;
         bytes12?: undefined;
         bytes13?: undefined;
         bytes14?: undefined;
         bytes15?: undefined;
         bytes16?: undefined;
         bytes17?: undefined;
+        bytes18?: undefined;
         bytes19?: undefined;
         bytes20?: undefined;
         bytes21?: undefined;

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/defaults.d.ts

@@ -1,6 +1,6 @@
 import { type Address, type Chain } from "viem";
 import type { EntryPointVersion } from "../entrypoint/types.js";
-import type { UserOperationFeeOptions } from "../types";
+import type { UserOperationFeeOptions } from "../types.js";
 /**
  * Utility method returning the default simple account factory address given a {@link Chain} object
  *

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

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/utils/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,MAAM,CAAC;AAuBhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,qCAAqC,UACzC,KAAK,YACH,iBAAiB,KACzB,OAqCF,CAAC;AAEF,eAAO,MAAM,4BAA4B,qBAIvC,CAAC;AAEH,eAAO,MAAM,iCAAiC,UACrC,KAAK,KACX,uBAOF,CAAC"}
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/utils/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,MAAM,CAAC;AAsBhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;;GAOG;AACH,eAAO,MAAM,qCAAqC,UACzC,KAAK,YACH,iBAAiB,KACzB,OAqCF,CAAC;AAEF,eAAO,MAAM,4BAA4B,qBAIvC,CAAC;AAEH,eAAO,MAAM,iCAAiC,UACrC,KAAK,KACX,uBAOF,CAAC"}

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

@@ -1,15 +1,5 @@
-import type { Chain } from "viem";
 import type { PromiseOrValue } from "../types.js";
 import type { RecordableKeys } from "./types.js";
-export declare const AlchemyChainMap: Map<number, Chain>;
-/**
- * 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 declare const getChain: (chainId: number) => Chain;
 /**
  * Utility function that allows for piping a series of async functions together
  *
@@ -34,8 +24,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 +76,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":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;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.2";
 //# 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.2",
   "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": "af70c1ea67be7f49339a1267ccadd8dc10aabde1"
 }

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,