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

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> {

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

@@ -1,3 +1,7 @@
+import {
+  smartAccountClientActions,
+  type SmartAccountSigner,
+} from "@aa-sdk/core";
 import {
   AlchemyProviderConfigSchema,
   createAlchemyPublicRpcClient,
@@ -19,10 +23,6 @@ import {
   type MultisigUserOperationContext,
   type PluginManagerActions,
 } from "@account-kit/smart-contracts";
-import {
-  smartAccountClientActions,
-  type SmartAccountSigner,
-} from "@aa-sdk/core";
 import {
   custom,
   type Chain,
@@ -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";
+ * 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<

package/src/msca/errors.ts

@@ -1,5 +1,8 @@
 import { BaseError } from "@aa-sdk/core";
 
+/**
+ * Error thrown when the aggregated signature is invalid
+ */
 export class InvalidAggregatedSignatureError extends BaseError {
   override name = "InvalidAggregatedSignatureError";
   constructor() {
@@ -7,6 +10,9 @@ export class InvalidAggregatedSignatureError extends BaseError {
   }
 }
 
+/**
+ * Error thrown when the context signature is invalid
+ */
 export class InvalidContextSignatureError extends BaseError {
   override name = "InvalidContextSignatureError";
   constructor() {
@@ -14,6 +20,9 @@ export class InvalidContextSignatureError extends BaseError {
   }
 }
 
+/**
+ * Error thrown when the expected account is not a multisig modular account
+ */
 export class MultisigAccountExpectedError extends BaseError {
   override name = "MultisigAccountExpectedError";
   constructor() {
@@ -21,6 +30,9 @@ export class MultisigAccountExpectedError extends BaseError {
   }
 }
 
+/**
+ * Error thrown when a multisig user op is missing a signature
+ */
 export class MultisigMissingSignatureError extends BaseError {
   override name = "MultisigMissingSignatureError";
   constructor() {

package/src/msca/plugin-manager/decorator.ts

@@ -27,7 +27,22 @@ export type PluginManagerActions<
   ) => Promise<SendUserOperationResult<TEntryPointVersion>>;
 };
 
-export const pluginManagerActions: <
+/**
+ * Provides actions for managing plugins on a given client, including installing and uninstalling plugins.
+ * NOTE: this is provided by default when using a modular account client
+ *
+ * @example
+ * ```ts
+ * import { pluginManagerActions } from "@account-kit/smart-contracts";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const client = createSmartAccountClient(...).extend(pluginManagerActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance on which to manage plugins
+ * @returns {PluginManagerActions<TAccount>} An object containing functions to install and uninstall plugins
+ */
+export function pluginManagerActions<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends SmartContractAccount | undefined =
@@ -35,7 +50,9 @@ export const pluginManagerActions: <
     | undefined
 >(
   client: Client<TTransport, TChain, TAccount>
-) => PluginManagerActions<TAccount> = (client) => ({
-  installPlugin: async (params) => installPlugin(client, params),
-  uninstallPlugin: async (params) => uninstallPlugin(client, params),
-});
+): PluginManagerActions<TAccount> {
+  return {
+    installPlugin: async (params) => installPlugin(client, params),
+    uninstallPlugin: async (params) => uninstallPlugin(client, params),
+  };
+}

package/src/msca/plugin-manager/installPlugin.ts

@@ -40,6 +40,27 @@ export type InstallPluginParams<
   GetAccountParameter<TAccount> &
   GetContextParameter<TContext>;
 
+/**
+ * Installs a plugin on a smart account via the client, sending the user operation with the appropriate parameters.
+ * NOTE: it's recommended to just use the installPlugin action returned from generated plugins
+ *
+ * @example
+ * ```ts
+ * import { installPlugin, createModularAccountAlchemyClient } from "@account-kit/smart-contracts";
+ *
+ * const client = createModularAccountAlchemyClient(...);
+ *
+ * const hash = await installPlugin(client, {
+ *  pluginAddress: "0x...",
+ *  manifestHash: "0x...",
+ *  dependencies: [], // this is defined by the plugin you're installing
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client configured to the smart account on which the plugin will be installed
+ * @param {InstallPluginParams<TAccount, TContext>} params The parameters required to install the plugin, including overrides, context, and account information
+ * @returns {Promise<any>} A promise that resolves once the plugin installation operation is sent
+ */
 export async function installPlugin<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/msca/plugins/multi-owner/extension.ts

@@ -33,6 +33,21 @@ export type MultiOwnerPluginActions<
       }
     : {});
 
+/**
+ * Creates actions for the MultiOwner plugin, including reading owners and checking ownership.
+ * NOTE: this is already added to the client returned from createMultiOwnerModularAccountClient
+ *
+ * @example
+ * ```ts
+ * import { multiOwnerPluginActions } from "@account-kit/smart-contracts";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const client = createSmartAccountClient(...).extend(multiOwnerPluginActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client the client instance containing the transport, chain, and account information
+ * @returns {MultiOwnerPluginActions<TAccount>} an object containing the actions for the MultiOwner plugin, such as `readOwners` and `isOwnerOf`
+ */
 export const multiOwnerPluginActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/msca/plugins/multi-owner/index.ts

@@ -1,6 +1,9 @@
 export type * from "./extension.js";
 export { multiOwnerPluginActions } from "./extension.js";
+
 export {
+  MultiOwnerPlugin,
   MultiOwnerPluginAbi,
   MultiOwnerPluginExecutionFunctionAbi,
+  type InstallMultiOwnerPluginParams,
 } from "./plugin.js";

package/src/msca/plugins/multisig/actions/proposeUserOperation.ts

@@ -10,8 +10,8 @@ import {
   type UserOperationOverrides,
 } from "@aa-sdk/core";
 import { type Chain, type Client, type Transport } from "viem";
-import { splitAggregatedSignature } from "../index.js";
 import { type ProposeUserOperationResult } from "../types.js";
+import { splitAggregatedSignature } from "../utils/splitAggregatedSignature.js";
 
 export async function proposeUserOperation<
   TTransport extends Transport = Transport,

package/src/msca/plugins/multisig/actions/signMultisigUserOperation.ts

@@ -8,11 +8,11 @@ import {
 } from "@aa-sdk/core";
 import { type Chain, type Client, type Transport } from "viem";
 import { MultisigMissingSignatureError } from "../../../errors.js";
-import { combineSignatures, splitAggregatedSignature } from "../index.js";
 import {
   type SignMultisigUserOperationParams,
   type SignMultisigUserOperationResult,
 } from "../types.js";
+import { combineSignatures, splitAggregatedSignature } from "../utils/index.js";
 
 export async function signMultisigUserOperation<
   TTransport extends Transport = Transport,

package/src/msca/plugins/multisig/extension.ts

@@ -58,6 +58,19 @@ export type MultisigPluginActions<
       }
     : {});
 
+/**
+ * Provides actions for managing a multisig plugin within the specified client, including reading owners, checking ownership, getting the threshold, proposing user operations, and signing multisig user operations.
+ *
+ * @example
+ * ```ts
+ * import { createModularAccountAlchemyClient, multisigPluginActions } from "@account-kit/smart-contracts";
+ *
+ * const client = createModularAccountAlchemyClient(...).extend(multisigPluginActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance configured with transport, chain, and account information
+ * @returns {MultisigPluginActions<TAccount>} An object containing methods to perform actions related to the multisig plugin
+ */
 export const multisigPluginActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/msca/plugins/multisig/index.ts

@@ -1,8 +1,3 @@
-export { getThreshold } from "./actions/getThreshold.js";
-export { isOwnerOf } from "./actions/isOwnerOf.js";
-export { proposeUserOperation } from "./actions/proposeUserOperation.js";
-export { readOwners } from "./actions/readOwners.js";
-export { signMultisigUserOperation } from "./actions/signMultisigUserOperation.js";
 export type * from "./extension.js";
 export { multisigPluginActions } from "./extension.js";
 export { multisigSignatureMiddleware } from "./middleware.js";
@@ -10,12 +5,6 @@ export {
   MultisigPlugin,
   MultisigPluginAbi,
   MultisigPluginExecutionFunctionAbi,
+  type InstallMultisigPluginParams,
 } from "./plugin.js";
 export type * from "./types.js";
-export { type SignerType } from "./types.js";
-export {
-  combineSignatures,
-  formatSignatures,
-  getSignerType,
-  splitAggregatedSignature,
-} from "./utils/index.js";

package/src/msca/plugins/multisig/middleware.ts

@@ -15,24 +15,24 @@ import {
   InvalidContextSignatureError,
   MultisigAccountExpectedError,
 } from "../../errors.js";
+import { type MultisigUserOperationContext } from "./types.js";
 import {
   combineSignatures,
   getSignerType,
   splitAggregatedSignature,
-  type MultisigUserOperationContext,
-} from "./index.js";
+} from "./utils/index.js";
 
 /**
  * A signer middleware to be used with Multisig Account Clients.
  * This middleware handles correctly aggregating signatures passed through
  * as context when sending UserOperations, proposing UserOperations, or adding signatures to a UserOperation.
  *
- * @param struct the user operation struct to be signed
- * @param param the parameters to be passed to the middleware
- * @param param.account the account to be used for signing
- * @param param.client the smart account client that will be used for RPC requests
- * @param param.context the context object containing the signatures to be aggregated {@link MultisigUserOperationContext}
- * @returns a Promise containing a UserOperation with an aggregated signature in the `signature` field
+ * @param {Deferrable<UserOperationStruct<TEntryPointVersion>>} struct the user operation struct to be signed
+ * @param {ClientMiddlewareArgs<TAccount, C, TContext, TEntryPointVersion>} args the parameters to be passed to the middleware
+ * @param {UserOperationOverrides<TEntryPointVersion>} args.account the account to be used for signing
+ * @param {MiddlewareClient} args.client the smart account client that will be used for RPC requests
+ * @param {MultisigUserOperationContext} args.context the context object containing the signatures to be aggregated MultisigUserOperationContext
+ * @returns {Promise<Deferrable<UserOperationStruct<TEntryPointVersion>>>} a Promise containing a UserOperation with an aggregated signature in the `signature` field
  */
 export const multisigSignatureMiddleware: ClientMiddlewareFn<
   MultisigUserOperationContext

package/src/msca/plugins/multisig/utils/combineSignatures.ts

@@ -2,23 +2,50 @@ import { type Hex, concat, pad } from "viem";
 import type { Signature } from "../types.js";
 import { formatSignatures } from "./formatSignatures.js";
 
-export const combineSignatures = ({
-  signatures,
-  upperLimitMaxFeePerGas,
-  upperLimitMaxPriorityFeePerGas,
-  upperLimitPvg,
-  usingMaxValues,
-}: {
+export type CombineSignaturesParams = {
   upperLimitPvg: Hex;
   upperLimitMaxFeePerGas: Hex;
   upperLimitMaxPriorityFeePerGas: Hex;
   signatures: Signature[];
   usingMaxValues: boolean;
-}) => {
+};
+
+/**
+ * Combines multiple signatures with provided upper limit values for gas fees and returns the concatenated result.
+ *
+ * @example
+ * ```ts
+ * import { combineSignatures } from "@account-kit/smart-contracts";
+ *
+ * const combinedSignature = combineSignatures({
+ *  // this is the upper limit pre-verification gas
+ *  upperLimitPvg: "0x01",
+ *  upperLimitMaxFeePerGas: "0x02",
+ *  upperLimitMaxPriorityFeePerGas: "0x03",
+ *  signatures: [{
+ *    signerType: "EOA",
+ *    userOpSigType: "UPPERLIMIT",
+ *    signer: `0x...`,
+ *    signature: `0x...`,
+ *  }]
+ *  usingMaxValues: false,
+ * });
+ * ```
+ *
+ * @param {CombineSignaturesParams} params The function parameters
+ * @returns {Hex} The concatenated result of padding and formatting the provided values and signatures
+ */
+export function combineSignatures({
+  signatures,
+  upperLimitMaxFeePerGas,
+  upperLimitMaxPriorityFeePerGas,
+  upperLimitPvg,
+  usingMaxValues,
+}: CombineSignaturesParams): Hex {
   return concat([
     pad(upperLimitPvg),
     pad(upperLimitMaxFeePerGas),
     pad(upperLimitMaxPriorityFeePerGas),
     formatSignatures(signatures, usingMaxValues),
   ]);
-};
+}

package/src/msca/plugins/multisig/utils/formatSignatures.ts

@@ -8,9 +8,9 @@ import type { Signature } from "../types";
  * by signer address. The EOA SIGS contain the 65 signautre data for EOA signers and 65 bytes containing SIGNER | OFFSET | V for contract signers.
  * The OFFSET is used to fetch the signature data from the CONTRACT_SIG_DATAS.
  *
- * @param signatures the array of {@link Signature} objects to combine into the correct aggregated signature format excluding the upper limits
- * @param usingMaxValues a boolean indicating wether or not the UserOperation is using the UPPER_LIMIT for the gas and fee values
- * @returns the Hex representation of the signature
+ * @param {Signature[]} signatures the array of Signature objects to combine into the correct aggregated signature format excluding the upper limits
+ * @param {boolean} usingMaxValues a boolean indicating wether or not the UserOperation is using the UPPER_LIMIT for the gas and fee values
+ * @returns {Hex} the Hex representation of the signature
  */
 export const formatSignatures = (
   signatures: Signature[],

package/src/msca/plugins/multisig/utils/getSignerType.ts

@@ -1,12 +1,12 @@
-import type { SmartContractAccount, SmartAccountSigner } from "@aa-sdk/core";
+import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import {
-  type Transport,
   type Chain,
   type Client,
-  type PublicRpcSchema,
-  type PublicActions,
   type Hex,
+  type PublicActions,
+  type PublicRpcSchema,
   size,
+  type Transport,
 } from "viem";
 import type { SignerType } from "../types";
 
@@ -29,6 +29,25 @@ type GetSignerTypeParams<
   client: TClient;
 };
 
+/**
+ * Determines the type of signer (Externally Owned Account (EOA) or CONTRACT) based on the provided client, signature, and signer.
+ *
+ * @example
+ * ```ts
+ * import { getSignerType } from "@account-kit/smart-contracts";
+ * import { LocalAccountSigner } from "@aa-sdk/core";
+ * import { createPublicClient, generatePrivateKey } from "viem";
+ *
+ * const signer = LocalAccountSigner.privateKeyToAccountSigner(generatePrivateKey());
+ * const client = createPublicClient(...);
+ * const signature = signer.signMessage("Hello World");
+ *
+ * const signerType = await getSignerType({ client, signature, signer }); // EOA
+ * ```
+ *
+ * @param {GetSignerTypeParams<TTransport, TChain>} params the parameters including the client, signature, and signer
+ * @returns {Promise<SignerType>} A promise that resolves to the signer type, which is either "EOA" or "CONTRACT"
+ */
 export const getSignerType = async <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined

package/src/msca/plugins/multisig/utils/index.ts

@@ -1,4 +1,8 @@
+export type * from "./combineSignatures.js";
 export { combineSignatures } from "./combineSignatures.js";
+export type * from "./formatSignatures.js";
 export { formatSignatures } from "./formatSignatures.js";
+export type * from "./getSignerType.js";
 export { getSignerType } from "./getSignerType.js";
+export type * from "./splitAggregatedSignature.js";
 export { splitAggregatedSignature } from "./splitAggregatedSignature.js";