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

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

@@ -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/chains";
+ * 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

@@ -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/chains";
+ * 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/chains";
+ *
+ * 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/chains";
+ *
+ * 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

@@ -168,21 +168,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 +218,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 +289,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 +306,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

@@ -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/chains";
+ * 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> {

package/src/msca/client/client.ts

@@ -80,6 +80,28 @@ export function createMultiOwnerModularAccountClient<
   >
 >;
 
+/**
+ * Creates a multi-owner modular account client with the provided parameters including account, transport, chain, and additional client configuration. This function uses a modular account and extends it with various plugin actions.
+ *
+ * @example
+ * ```ts
+ * import { createMultiOwnerModularAccountClient } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const accountClient = await createMultiOwnerModularAccountClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  account: {
+ *    signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey())
+ *  }
+ * });
+ * ```
+ *
+ * @param {CreateMultiOwnerModularAccountClientParams} config The parameters for creating the multi-owner modular account client
+ * @returns {Promise<SmartAccountClient>} A promise that resolves to a `SmartAccountClient` instance with extended plugin actions
+ */
 export async function createMultiOwnerModularAccountClient({
   account,
   transport,
@@ -121,6 +143,30 @@ export function createMultisigModularAccountClient<
   >
 >;
 
+/**
+ * Creates a multisig modular account client using the provided parameters including account details, transport, chain, and additional client configuration. This function constructs the multisig modular account and extends it with various actions to create a comprehensive client.
+ *
+ * @example
+ * ```ts
+ * import { createMultisigModularAccountClient } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { sepolia } from "viem/chains";
+ * import { http, generatePrivateKey } from "viem"
+ *
+ * const accountClient = await createMultisigModularAccountClient({
+ *  chain: sepolia,
+ *  transport: http("RPC_URL"),
+ *  account: {
+ *    signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey()),
+ *    owners: [...], // other owners on the account
+ *    threshold: 2, // 2 of N signatures
+ *  }
+ * });
+ * ```
+ *
+ * @param {CreateMultisigModularAccountClientParams} config the parameters for configuring the multisig modular account client
+ * @returns {Promise<SmartAccountClient<Transport, Chain, MultisigModularAccount<SmartAccountSigner>, {}, SmartAccountClientRpcSchema, MultisigUserOperationContext>>} a promise that resolves to a `SmartAccountClient` object extended with the multisig modular account and additional actions
+ */
 export async function createMultisigModularAccountClient({
   account,
   transport,

package/src/msca/client/multiSigAlchemyClient.ts

@@ -65,6 +65,28 @@ export function createMultisigAccountAlchemyClient<
   >
 >;
 
+/**
+ * Creates an Alchemy client for a multisig account using the provided configuration.
+ *
+ * @example
+ * ```ts
+ * import { createMultisigAccountAlchemyClient } from "@account-kit/smart-contracts";
+ * import { sepolia } from "@account-kit/infra/chains";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { generatePrivateKey } from "viem"
+ *
+ * const alchemyAccountClient = await createMultisigAccountAlchemyClient({
+ *  apiKey: "your-api-key",
+ *  chain: sepolia,
+ *  signer: LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey()),
+ *  owners: [...], // other owners on the account
+ *  threshold: 2, // 2 of N signatures
+ * });
+ * ```
+ *
+ * @param {AlchemyMultisigAccountClientConfig} config The configuration for the Alchemy multisig account client
+ * @returns {Promise<AlchemySmartAccountClient<Transport, Chain | undefined, MultisigModularAccount<SmartAccountSigner>, MultisigPluginActions<MultisigModularAccount<SmartAccountSigner>> & PluginManagerActions<MultisigModularAccount<SmartAccountSigner>> & AccountLoupeActions<MultisigModularAccount<SmartAccountSigner>>, MultisigUserOperationContext>>} A promise that resolves to an Alchemy Smart Account Client for multisig accounts with extended functionalities.
+ */
 export async function createMultisigAccountAlchemyClient(
   config: AlchemyMultisigAccountClientConfig
 ): Promise<