@account-kit/smart-contracts 4.0.0-alpha.0 → 4.0.0-alpha.2

package/src/light-account/accounts/multiOwner.ts

@@ -23,6 +23,7 @@ import type {
 import {
   AccountVersionRegistry,
   defaultLightAccountVersion,
+  getDefaultMultiOwnerLightAccountFactoryAddress,
 } from "../utils.js";
 import {
   createLightAccountBase,
@@ -105,6 +106,26 @@ export async function createMultiOwnerLightAccount<
   MultiOwnerLightAccount<TSigner, TLightAccountVersion, TEntryPointVersion>
 >;
 
+/**
+ * Creates a multi-owner light account using the provided parameters, including transport, chain, signer, initialization code, version, account address, factory address, salt, and owners. Ensures the owners list is deduplicated, ordered, and valid.
+ *
+ * @example
+ * ```ts
+ * import { createMultiOwnerLightAccount } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const account = await createMultiOwnerLightAccount({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ * });
+ * ```
+ *
+ * @param {CreateMultiOwnerLightAccountParams} config The parameters for creating a multi-owner light account
+ * @returns {Promise<MultiOwnerLightAccount>} A promise that resolves to a `MultiOwnerLightAccount` object containing the created account information and methods
+ */
 export async function createMultiOwnerLightAccount({
   transport,
   chain,
@@ -112,13 +133,13 @@ export async function createMultiOwnerLightAccount({
   initCode,
   version = defaultLightAccountVersion("MultiOwnerLightAccount"),
   entryPoint = getEntryPoint(chain, {
-    version:
-      AccountVersionRegistry["MultiOwnerLightAccount"][version]
-        .entryPointVersion,
+    version: "0.7.0",
   }),
   accountAddress,
-  factoryAddress = AccountVersionRegistry["MultiOwnerLightAccount"][version]
-    .address[chain.id].factory,
+  factoryAddress = getDefaultMultiOwnerLightAccountFactoryAddress(
+    chain,
+    version
+  ),
   salt: salt_ = 0n,
   owners = [],
 }: CreateMultiOwnerLightAccountParams): Promise<MultiOwnerLightAccount> {

package/src/light-account/actions/transferOwnership.ts

@@ -22,7 +22,32 @@ export type TransferLightAccountOwnershipParams<
 } & GetAccountParameter<TAccount, LightAccount<TSigner>> &
   UserOperationOverridesParameter<TEntryPointVersion>;
 
-export const transferOwnership: <
+/**
+ * Transfers the ownership of a light account to a new owner.
+ * This function ensures that the client is a compatible smart acccount client and that a Light Account is provided.
+ * If the waitForTxn parameter is true, it will wait for the transaction to be completed before returning.
+ *
+ * @example
+ * ```ts
+ * import { transferOwnership, createLightAccountClient } from "@account-kit/smart-contracts";
+ *
+ * const lightAccountClient = createLightAccountClient({
+ *  signer,
+ *  transport,
+ *  chain,
+ * });
+ *
+ * const txHash = await transferOwnership(lightAccountClient, {
+ *  newOwner: newOwnerSigner,
+ *  waitForTxn: true, // set to false to return a uoHash instead
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The smart account client instance used to execute the transfer
+ * @param {TransferLightAccountOwnershipParams<TSigner, TAccount>} args The parameters for transferring ownership
+ * @returns {Promise<Hex>} The transaction or UO hash as a Hex string
+ */
+export const transferOwnership = async <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TSigner extends SmartAccountSigner = SmartAccountSigner,
@@ -32,10 +57,8 @@ export const transferOwnership: <
 >(
   client: Client<TTransport, TChain, TAccount>,
   args: TransferLightAccountOwnershipParams<TSigner, TAccount>
-) => Promise<Hex> = async (
-  client,
-  { newOwner, waitForTxn, overrides, account = client.account }
-) => {
+): Promise<Hex> => {
+  const { newOwner, waitForTxn, overrides, account = client.account } = args;
   if (!account) {
     throw new AccountNotFoundError();
   }

package/src/light-account/actions/updateOwners.ts

@@ -23,6 +23,30 @@ export type UpdateMultiOwnerLightAccountOwnersParams<
 } & GetAccountParameter<TAccount, MultiOwnerLightAccount<TSigner>> &
   UserOperationOverridesParameter<TEntryPointVersion>;
 
+/**
+ * Updates the owners of a multi-owner light account. This includes adding new owners and removing existing ones.
+ *
+ * @example
+ * ```ts
+ * import { updateOwners, createLightAccountClient } from "@account-kit/smart-contracts";
+ *
+ * const lightAccountClient = createLightAccountClient({
+ *  signer,
+ *  transport,
+ *  chain,
+ * });
+ *
+ * const txHash = await updateOwners(lightAccountClient, {
+ *  ownerstoAdd: [newOwnerAddress], // or empty if you just want to remove owners
+ *  ownersToRemove: [oldOwnerAddress], // or empty if you just want to add owners
+ *  waitForTxn: true, // set to false to return a uoHash instead
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance used to interact with the account
+ * @param {UpdateMultiOwnerLightAccountOwnersParams<TSigner, TAccount>} args The parameters for updating the account owners
+ * @returns {Promise<Hex>} A promise that resolves to the transaction hash or the full transaction result if `waitForTxn` is `true`
+ */
 export const updateOwners: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/light-account/clients/alchemyClient.ts

@@ -1,3 +1,4 @@
+import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
 import {
   AlchemyProviderConfigSchema,
   createAlchemyPublicRpcClient,
@@ -12,7 +13,6 @@ import {
   type LightAccount,
   type LightAccountClientActions,
 } from "@account-kit/smart-contracts";
-import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
 import { custom, type Chain, type CustomTransport, type Transport } from "viem";
 
 export type AlchemyLightAccountClientConfig<
@@ -39,6 +39,26 @@ export async function createLightAccountAlchemyClient<
   >
 >;
 
+/**
+ * Creates an Alchemy smart account client connected to a Light Account instance.
+ *
+ * @example
+ * ```ts
+ * import { createLightAccountAlchemyClient } from "@account-kit/smart-contracts";
+ * import { sepolia } from "@account-kit/infra";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { generatePrivateKey } from "viem"
+ *
+ * const lightAccountClient = await createLightAccountAlchemyClient({
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ * });
+ * ```
+ *
+ * @param {AlchemyLightAccountClientConfig} config The configuration for setting up the Alchemy Light Account Client
+ * @returns {Promise<AlchemySmartAccountClient>} A promise that resolves to an `AlchemySmartAccountClient` object containing the created client
+ */
 export async function createLightAccountAlchemyClient(
   config: AlchemyLightAccountClientConfig
 ): Promise<AlchemySmartAccountClient> {

package/src/light-account/clients/client.ts

@@ -48,12 +48,33 @@ export function createLightAccountClient<
   >
 >;
 
-export async function createLightAccountClient({
-  account,
-  transport,
-  chain,
-  ...clientConfig
-}: CreateLightAccountClientParams): Promise<SmartAccountClient> {
+/**
+ * Creates a light account client using the provided parameters, including account information, transport mechanism, blockchain chain, and additional client configurations. This function first creates a light account and then uses it to create a smart account client, extending it with light account client actions.
+ *
+ * @example
+ * ```ts
+ * import { createLightAccountClient } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const account = await createLightAccountClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  account: {
+ *    signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ *  }
+ * });
+ * ```
+ *
+ * @param {CreateLightAccountClientParams} params The parameters for creating a light account client
+ * @returns {Promise<SmartAccountClient>} A promise that resolves to a `SmartAccountClient` object containing the created account information and methods
+ */
+export async function createLightAccountClient(
+  params: CreateLightAccountClientParams
+): Promise<SmartAccountClient> {
+  const { account, transport, chain, ...clientConfig } = params;
+
   const lightAccount = await createLightAccount({
     ...account,
     transport,

package/src/light-account/clients/multiOwnerAlchemyClient.ts

@@ -1,3 +1,4 @@
+import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
 import {
   AlchemyProviderConfigSchema,
   createAlchemyPublicRpcClient,
@@ -12,7 +13,6 @@ import {
   type MultiOwnerLightAccount,
   type MultiOwnerLightAccountClientActions,
 } from "@account-kit/smart-contracts";
-import type { HttpTransport, SmartAccountSigner } from "@aa-sdk/core";
 import { custom, type Chain, type CustomTransport, type Transport } from "viem";
 
 export type AlchemyMultiOwnerLightAccountClientConfig<
@@ -43,6 +43,26 @@ export async function createMultiOwnerLightAccountAlchemyClient<
   >
 >;
 
+/**
+ * Creates a multi-owner light account Alchemy client using the provided configuration.
+ *
+ * @example
+ * ```ts
+ * import { createMultiOwnerLightAccountAlchemyClient } from "@account-kit/smart-contracts";
+ * import { sepolia } from "@account-kit/infra";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { generatePrivateKey } from "viem"
+ *
+ * const lightAccountClient = await createMultiOwnerLightAccountAlchemyClient({
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ * });
+ * ```
+ *
+ * @param {AlchemyMultiOwnerLightAccountClientConfig} config The configuration for creating the Alchemy client
+ * @returns {Promise<AlchemySmartAccountClient>} A promise that resolves to an `AlchemySmartAccountClient` object containing the created account information and methods
+ */
 export async function createMultiOwnerLightAccountAlchemyClient(
   config: AlchemyMultiOwnerLightAccountClientConfig
 ): Promise<AlchemySmartAccountClient> {

package/src/light-account/clients/multiOwnerLightAccount.ts

@@ -54,12 +54,33 @@ export function createMultiOwnerLightAccountClient<
   >
 >;
 
-export async function createMultiOwnerLightAccountClient({
-  account,
-  transport,
-  chain,
-  ...clientConfig
-}: CreateMultiOwnerLightAccountClientParams): Promise<SmartAccountClient> {
+/**
+ * Creates a multi-owner light account client using the provided parameters. It first creates a multi-owner light account and then creates a smart account client with the provided configurations.
+ *
+ * @example
+ * ```ts
+ * import { createMultiOwnerLightAccountClient } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const account = await createMultiOwnerLightAccountClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  account: {
+ *    signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ *  }
+ * });
+ * ```
+ *
+ * @param {CreateMultiOwnerLightAccountClientParams} params the configuration for creating the multi-owner light account client
+ * @returns {Promise<SmartAccountClient>} a promise that resolves to a `SmartAccountClient` containing the created account client and relevant methods
+ */
+export async function createMultiOwnerLightAccountClient(
+  params: CreateMultiOwnerLightAccountClientParams
+): Promise<SmartAccountClient> {
+  const { account, transport, chain, ...clientConfig } = params;
+
   const lightAccount = await createMultiOwnerLightAccount({
     ...account,
     transport,

package/src/light-account/decorators/lightAccount.ts

@@ -17,6 +17,25 @@ export type LightAccountClientActions<
   ) => Promise<Hex>;
 };
 
+/**
+ * Provides a set of actions for managing a light account client, including transferring ownership.
+ *
+ * @example
+ * ```ts
+ * import { lightAccountClientActions, createLightAccount } from "@account-kit/smart-contracts";
+ * import { createAlchemySmartAccountClient } from "@account-kit/infra";
+ * import { sepolia } from "@account-kit/infra";
+ *
+ * const smartAccountClient = createAlchemySmartAccountClient({
+ *  account: await createLightAccount(...),
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ * }).extend(lightAccountClientActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance for which to provide the light account actions
+ * @returns {LightAccountClientActions<TSigner, TAccount>} An object containing the available light account client actions
+ */
 export const lightAccountClientActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/light-account/decorators/multiOwnerLightAccount.ts

@@ -17,6 +17,25 @@ export type MultiOwnerLightAccountClientActions<
   ) => Promise<Hex>;
 };
 
+/**
+ * Generates client actions for a multi-owner light account, including the ability to update owners.
+ *
+ * @example
+ * ```ts
+ * import { multiOwnerLightAccountClientActions, createMultiOwnerLightAccount } from "@account-kit/smart-contracts";
+ * import { createAlchemySmartAccountClient } from "@account-kit/infra";
+ * import { sepolia } from "@account-kit/infra";
+ *
+ * const smartAccountClient = createAlchemySmartAccountClient({
+ *  account: await createMultiOwnerLightAccount(...),
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ * }).extend(multiOwnerLightAccountClientActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the client for interacting with the multi-owner light account
+ * @returns {MultiOwnerLightAccountClientActions<TSigner, TAccount>} an object containing the client actions specifically for a multi-owner light account
+ */
 export const multiOwnerLightAccountClientActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/light-account/utils.ts

@@ -1,5 +1,5 @@
+import { DefaultFactoryNotDefinedError, toRecord } from "@aa-sdk/core";
 import {
-  DefaultFactoryNotDefinedError,
   arbitrum,
   arbitrumGoerli,
   arbitrumSepolia,
@@ -17,10 +17,9 @@ import {
   polygonAmoy,
   polygonMumbai,
   sepolia,
-  toRecord,
   zora,
   zoraSepolia,
-} from "@aa-sdk/core";
+} from "@account-kit/infra";
 import { fromHex, type Address, type Chain } from "viem";
 import type { LightAccountBase } from "./accounts/base";
 import type {
@@ -168,21 +167,45 @@ export const defaultLightAccountVersion = <
  */
 export const getDefaultLightAccountFactoryAddress = (
   chain: Chain,
-  version: LightAccountVersion = "v1.1.0"
+  version: GetLightAccountVersion<"LightAccount">
 ): Address => {
   const address =
-    AccountVersionRegistry.LightAccount[version].address[chain.id];
+    AccountVersionRegistry.LightAccount[version].address[chain.id] ??
+    AccountVersionRegistry.LightAccount[version].address[supportedChains[0].id];
   if (!address)
     throw new DefaultFactoryNotDefinedError("LightAccount", chain, "0.6.0");
   return address.factory;
 };
 
+/**
+ * Utility method returning the default multi owner light account factory address given a {@link Chain} object
+ *
+ * @param chain - a {@link Chain} object
+ * @param version - the version of the light account to get the factory address for
+ * @returns a {@link Address} for the given chain
+ * @throws if the chain doesn't have an address currently deployed
+ */
+export const getDefaultMultiOwnerLightAccountFactoryAddress = (
+  chain: Chain,
+  version: GetLightAccountVersion<"MultiOwnerLightAccount">
+) => {
+  const address =
+    AccountVersionRegistry.LightAccount[version].address[chain.id] ??
+    AccountVersionRegistry.LightAccount[version].address[supportedChains[0].id];
+  if (!address)
+    throw new DefaultFactoryNotDefinedError(
+      "MultiOwnerLightAccount",
+      chain,
+      "0.7.0"
+    );
+  return address.factory;
+};
+
 /**
  * Can be used to check if the account with one of the following implementation addresses
  * to not support 1271 signing.
  *
  * Light accounts with versions v1.0.1 and v1.0.2 do not support 1271 signing.
- *
  */
 export const LightAccountUnsupported1271Impls = [
   AccountVersionRegistry.LightAccount["v1.0.1"],
@@ -194,7 +217,6 @@ export const LightAccountUnsupported1271Impls = [
  * to not support 1271 signing.
  *
  * Light accounts with versions v1.0.1 and v1.0.2 do not support 1271 signing.
- *
  */
 export const LightAccountUnsupported1271Factories = new Set(
   LightAccountUnsupported1271Impls.map((x) =>
@@ -266,7 +288,7 @@ export async function getLightAccountVersionDef<
         ];
         return chain.id in def.address
           ? [def.address[chain.id].impl, version]
-          : [null, version];
+          : [def.address[supportedChains[0].id].impl, version];
       })
       .filter(([impl]) => impl !== null) as [
       Address,
@@ -283,7 +305,7 @@ export async function getLightAccountVersionDef<
         ];
         return chain.id in def.address
           ? [def.address[chain.id].factory, version]
-          : [null, version];
+          : [def.address[supportedChains[0].id].factory, version];
       })
       .filter(([impl]) => impl !== null) as [
       Address,

package/src/msca/account/multiOwnerAccount.ts

@@ -62,17 +62,42 @@ export async function createMultiOwnerModularAccount<
   config: CreateMultiOwnerModularAccountParams<TTransport, TSigner>
 ): Promise<MultiOwnerModularAccount<TSigner>>;
 
-export async function createMultiOwnerModularAccount({
-  transport,
-  chain,
-  signer,
-  accountAddress,
-  initCode,
-  entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
-  factoryAddress = getDefaultMultiOwnerModularAccountFactoryAddress(chain),
-  owners = [],
-  salt = 0n,
-}: CreateMultiOwnerModularAccountParams): Promise<MultiOwnerModularAccount> {
+/**
+ * Creates a multi-owner modular account with the given parameters, including transport, chain, signer, account address, initialization code, entry point, factory address, owners, and salt.
+ * Ensures that the owners are unique, ordered, and non-zero.
+ *
+ * @example
+ * ```ts
+ * import { createMultiOwnerModularAccount } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const account = await createMultiOwnerModularAccount({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ * });
+ * ```
+ *
+ * @param {CreateMultiOwnerModularAccountParams} config Configuration parameters for creating a multi-owner modular account
+ * @returns {Promise<MultiOwnerModularAccount>} A promise that resolves to a `MultiOwnerModularAccount` object containing the created account information and methods
+ */
+export async function createMultiOwnerModularAccount(
+  config: CreateMultiOwnerModularAccountParams
+): Promise<MultiOwnerModularAccount> {
+  const {
+    transport,
+    chain,
+    signer,
+    accountAddress,
+    initCode,
+    entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
+    factoryAddress = getDefaultMultiOwnerModularAccountFactoryAddress(chain),
+    owners = [],
+    salt = 0n,
+  } = config;
+
   const client = createBundlerClient({
     transport,
     chain,

package/src/msca/account/multisigAccount.ts

@@ -64,18 +64,44 @@ export async function createMultisigModularAccount<
   config: CreateMultisigModularAccountParams<TTransport, TSigner>
 ): Promise<MultisigModularAccount<TSigner>>;
 
-export async function createMultisigModularAccount({
-  transport,
-  chain,
-  signer,
-  accountAddress,
-  initCode,
-  entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
-  factoryAddress = getDefaultMultisigModularAccountFactoryAddress(chain),
-  owners = [],
-  salt = 0n,
-  threshold,
-}: CreateMultisigModularAccountParams): Promise<MultisigModularAccount> {
+/**
+ * Creates a multisig modular account using the provided parameters, including transport, chain, signer, account address, and other account settings. It configures the account with multiple owners and the specified threshold.
+ *
+ * @example
+ * ```ts
+ * import { createMultisigModularAccount } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const account = await createMultisigModularAccount({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey()),
+ *  owners: [...], // other owners on the account
+ *  threshold: 2, // 2 of N signatures
+ * });
+ * ```
+ *
+ * @param {CreateMultisigModularAccountParams} config The parameters for creating a multisig modular account.
+ * @returns {Promise<MultisigModularAccount>} A promise that resolves to a `MultisigModularAccount` object containing the created account information and methods.
+ */
+export async function createMultisigModularAccount(
+  config: CreateMultisigModularAccountParams
+): Promise<MultisigModularAccount> {
+  const {
+    transport,
+    chain,
+    signer,
+    accountAddress: accountAddress_,
+    initCode,
+    entryPoint = getEntryPoint(chain, { version: "0.6.0" }),
+    factoryAddress = getDefaultMultisigModularAccountFactoryAddress(chain),
+    owners = [],
+    salt = 0n,
+    threshold,
+  } = config;
+
   const client = createBundlerClient({
     transport,
     chain,
@@ -108,10 +134,10 @@ export async function createMultisigModularAccount({
     ]);
   };
 
-  accountAddress = await getAccountAddress({
+  const accountAddress = await getAccountAddress({
     client,
     entryPoint,
-    accountAddress: accountAddress,
+    accountAddress: accountAddress_,
     getAccountInitCode,
   });
 

package/src/msca/account-loupe/decorator.ts

@@ -51,6 +51,21 @@ export type AccountLoupeActions<
   ): Promise<ReadonlyArray<Address>>;
 };
 
+/**
+ * Provides a set of actions for account loupe operations using the specified client.
+ * NOTE: this is already added to the client when using any of the Modular Account Clients.
+ *
+ * @example
+ * ```ts
+ * import { accountLoupeActions } from "@account-kit/smart-contracts";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const client = createSmartAccountClient(...).extend(accountLoupeActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the client to be used for executing the account loupe actions
+ * @returns {AccountLoupeActions<TAccount>} an object containing account loupe actions like `getExecutionFunctionConfig`, `getExecutionHooks`, `getPreValidationHooks`, and `getInstalledPlugins`
+ */
 export const accountLoupeActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/msca/client/alchemyClient.ts

@@ -1,3 +1,4 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
 import {
   AlchemyProviderConfigSchema,
   createAlchemyPublicRpcClient,
@@ -17,7 +18,6 @@ import {
   type MultiOwnerPluginActions,
   type PluginManagerActions,
 } from "@account-kit/smart-contracts";
-import type { SmartAccountSigner } from "@aa-sdk/core";
 import {
   custom,
   type Chain,
@@ -52,6 +52,26 @@ export function createModularAccountAlchemyClient<
   >
 >;
 
+/**
+ * Creates a modular account Alchemy client with the provided configuration.
+ *
+ * @example
+ * ```ts
+ * import { createModularAccountAlchemyClient } from "@account-kit/smart-contracts";
+ * import { sepolia } from "@account-kit/infra";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { generatePrivateKey } from "viem"
+ *
+ * const alchemyAccountClient = await createModularAccountAlchemyClient({
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ * });
+ * ```
+ *
+ * @param {AlchemyModularAccountClientConfig} config The configuration for creating the Alchemy client
+ * @returns {Promise<AlchemySmartAccountClient>} A promise that resolves to an `AlchemySmartAccountClient` configured with the desired plugins and actions
+ */
 export async function createModularAccountAlchemyClient(
   config: AlchemyModularAccountClientConfig
 ): Promise<AlchemySmartAccountClient> {