@account-kit/signer 4.0.0-alpha.5 → 4.0.0-alpha.6

package/src/base.ts

@@ -44,6 +44,10 @@ type InternalStore = Mutate<
   [["zustand/subscribeWithSelector", never]]
 >;
 
+/**
+ * Base abstract class for Alchemy Signer, providing authentication and session management for smart accounts.
+ * Implements the `SmartAccountAuthenticator` interface and handles various signer events.
+ */
 export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   implements SmartAccountAuthenticator<AuthParams, User, TClient>
 {
@@ -52,6 +56,15 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   private sessionManager: SessionManager;
   private store: InternalStore;
 
+  /**
+   * Initializes an instance with the provided client and session configuration.
+   * This function sets up the internal store, initializes the session manager,
+   * registers listeners and initializes the session manager to manage session state.
+   *
+   * @param {BaseAlchemySignerParams<TClient>} param0 Object containing the client and session configuration
+   * @param {TClient} param0.client The client instance to be used internally
+   * @param {SessionConfig} param0.sessionConfig Configuration for managing sessions
+   */
   constructor({ client, sessionConfig }: BaseAlchemySignerParams<TClient>) {
     this.inner = client;
     this.store = createStore(
@@ -88,9 +101,9 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   /**
    * Allows you to subscribe to events emitted by the signer
    *
-   * @param event the event to subscribe to
-   * @param listener the function to run when the event is emitted
-   * @returns a function to remove the listener
+   * @param {AlchemySignerEvent} event the event to subscribe to
+   * @param {AlchemySignerEvents[AlchemySignerEvent]} listener the function to run when the event is emitted
+   * @returns {() => void} a function to remove the listener
    */
   on = <E extends AlchemySignerEvent>(
     event: E,
@@ -132,8 +145,29 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   /**
    * Authenticate a user with either an email or a passkey and create a session for that user
    *
-   * @param params - undefined if passkey login, otherwise an object with email and bundle to resolve
-   * @returns the user that was authenticated
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const result = await signer.authenticate({
+   *  type: "email",
+   *  email: "foo@mail.com",
+   * });
+   * ```
+   *
+   * @param {AuthParams} params - undefined if passkey login, otherwise an object with email and bundle to resolve
+   * @returns {Promise<User>} the user that was authenticated
    */
   authenticate: (params: AuthParams) => Promise<User> = async (params) => {
     if (params.type === "email") {
@@ -144,7 +178,27 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   /**
-   * NOTE: right now this only clears the session locally.
+   * Clear a user session and log them out
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * await signer.disconnect();
+   * ```
+   *
+   * @returns {Promise<void>} a promise that resolves when the user is logged out
    */
   disconnect: () => Promise<void> = async () => {
     await this.inner.disconnect();
@@ -155,10 +209,29 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * If a user has an ongoing session, it will use that session and
    * try to authenticate
    *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * // throws if not logged in
+   * const user = await signer.getAuthDetails();
+   * ```
+   *
    * @throws if there is no user logged in
-   * @returns the current user
+   * @returns {Promise<User>} the current user
    */
-  getAuthDetails: () => Promise<User> = async () => {
+  getAuthDetails = async (): Promise<User> => {
     const sessionUser = await this.sessionManager.getSessionUser();
     if (sessionUser != null) {
       return sessionUser;
@@ -167,12 +240,41 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     return this.inner.whoami();
   };
 
+  /**
+   * Retrieves the address of the current user by calling the `whoami` method on `this.inner`.
+   *
+   * @returns {Promise<string>} A promise that resolves to the address of the current user.
+   */
   getAddress: () => Promise<`0x${string}`> = async () => {
     const { address } = await this.inner.whoami();
 
     return address;
   };
 
+  /**
+   * Signs a raw message after hashing it.
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const signature = await signer.signMessage("Hello, world!");
+   * ```
+   *
+   * @param {string} msg the message to be hashed and then signed
+   * @returns {Promise<string>} a promise that resolves to the signed message
+   */
   signMessage: (msg: SignableMessage) => Promise<`0x${string}`> = async (
     msg
   ) => {
@@ -181,6 +283,35 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     return this.inner.signRawMessage(messageHash);
   };
 
+  /**
+   * Signs a typed message by first hashing it and then signing the hashed message using the `signRawMessage` method.
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const signature = await signer.signTypedData({
+   *  domain: {},
+   *  types: {},
+   *  primaryType: "",
+   *  message: {},
+   * });
+   * ```
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} params The parameters for the typed message to be hashed and signed
+   * @returns {Promise<any>} A promise that resolves to the signed message
+   */
   signTypedData: <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
@@ -192,6 +323,36 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     return this.inner.signRawMessage(messageHash);
   };
 
+  /**
+   * Serializes a transaction, signs it with a raw message, and then returns the serialized transaction with the signature.
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const tx = await signer.signTransaction({
+   *  to: "0x1234",
+   *  value: "0x1234",
+   *  data: "0x1234",
+   * });
+   * ```
+   *
+   * @param {Transaction} tx the transaction to be serialized and signed
+   * @param {{serializer?: SerializeTransactionFn}} args options for serialization
+   * @param {() => Hex} [args.serializer] an optional serializer function. If not provided, the default `serializeTransaction` function will be used
+   * @returns {Promise<string>} a promise that resolves to the serialized transaction with the signature
+   */
   signTransaction: CustomSource["signTransaction"] = async (tx, args) => {
     const serializeFn = args?.serializer ?? serializeTransaction;
     const serializedTx = serializeFn(tx);
@@ -211,8 +372,26 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   /**
    * Unauthenticated call to look up a user's organizationId by email
    *
-   * @param email the email to lookup
-   * @returns the organization id for the user if they exist
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const result = await signer.getUser("foo@mail.com");
+   * ```
+   *
+   * @param {string} email the email to lookup
+   * @returns {Promise<{orgId: string}>} the organization id for the user if they exist
    */
   getUser: (email: string) => Promise<{ orgId: string } | null> = async (
     email
@@ -231,8 +410,26 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   /**
    * Adds a passkey to the user's account
    *
-   * @param params optional parameters for the passkey creation
-   * @returns an array of the authenticator ids added to the user
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const result = await signer.addPasskey()
+   * ```
+   *
+   * @param {CredentialCreationOptions | undefined} params optional parameters for the passkey creation
+   * @returns {Promise<string[]>} an array of the authenticator ids added to the user
    */
   addPasskey: (params?: CredentialCreationOptions) => Promise<string[]> =
     async (params) => {
@@ -244,8 +441,27 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * If the user is authenticated with an Email, this will return a seed phrase
    * If the user is authenticated with a Passkey, this will return a private key
    *
-   * @param params export wallet parameters
-   * @returns true if the wallet was exported successfully
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * // the params passed to this are different based on the specific signer
+   * const result = signer.exportWallet()
+   * ```
+   *
+   * @param {unknown} params export wallet parameters
+   * @returns {boolean} true if the wallet was exported successfully
    */
   exportWallet: (
     params: Parameters<(typeof this.inner)["exportWallet"]>[0]
@@ -257,10 +473,28 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * This method lets you adapt your AlchemySigner to a viem LocalAccount, which
    * will let you use the signer as an EOA directly.
    *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const account = signer.toViemAccount();
+   * ```
+   *
    * @throws if your signer is not authenticated
-   * @returns a LocalAccount object that can be used with viem's wallet client
+   * @returns {LocalAccount} a LocalAccount object that can be used with viem's wallet client
    */
-  toViemAccount: () => LocalAccount = () => {
+  toViemAccount = (): LocalAccount => {
     // if we want this method to be synchronous, then we need to do this check here
     // otherwise we can use the sessionManager to get the user
     if (!this.inner.getUser()) {

package/src/client/base.ts

@@ -71,10 +71,23 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     this._user = user;
   }
 
+  /**
+   * Sets the stamper of the TurnkeyClient.
+   *
+   * @param {TurnkeyClient["stamper"]} stamper the stamper function to set for the TurnkeyClient
+   */
   protected setStamper(stamper: TurnkeyClient["stamper"]) {
     this.turnkeyClient.stamper = stamper;
   }
 
+  /**
+   * Exports wallet credentials based on the specified type, either as a SEED_PHRASE or PRIVATE_KEY.
+   *
+   * @param {object} params The parameters for exporting the wallet
+   * @param {ExportWalletStamper} params.exportStamper The stamper used for exporting the wallet
+   * @param {"SEED_PHRASE" | "PRIVATE_KEY"} params.exportAs Specifies the format for exporting the wallet, either as a SEED_PHRASE or PRIVATE_KEY
+   * @returns {Promise<boolean>} A promise that resolves to true if the export is successful
+   */
   protected exportWalletInner(params: {
     exportStamper: ExportWalletStamper;
     exportAs: "SEED_PHRASE" | "PRIVATE_KEY";
@@ -120,9 +133,9 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   /**
    * Listen to events emitted by the client
    *
-   * @param event the event you want to listen to
-   * @param listener the callback function to execute when an event is fired
-   * @returns a function that will remove the listener when called
+   * @param {AlchemySignerClientEvent} event the event you want to listen to
+   * @param {AlchemySignerClientEvents[AlchemySignerClientEvent]} listener the callback function to execute when an event is fired
+   * @returns {() => void} a function that will remove the listener when called
    */
   public on = <E extends AlchemySignerClientEvent>(
     event: E,
@@ -133,6 +146,13 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return () => this.eventEmitter.removeListener(event, listener as any);
   };
 
+  /**
+   * Handles the creation of authenticators using WebAuthn attestation and the provided options. Requires the user to be authenticated.
+   *
+   * @param {CredentialCreationOptions} options The options used to create the WebAuthn attestation
+   * @returns {Promise<string[]>} A promise that resolves to an array of authenticator IDs
+   * @throws {NotAuthenticatedError} If the user is not authenticated
+   */
   public addPasskey = async (options: CredentialCreationOptions) => {
     if (!this.user) {
       throw new NotAuthenticatedError();
@@ -166,6 +186,13 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return authenticatorIds;
   };
 
+  /**
+   * Retrieves the current user or fetches the user information if not already available.
+   *
+   * @param {string} [orgId] optional organization ID, defaults to the user's organization ID
+   * @returns {Promise<User>} A promise that resolves to the user object
+   * @throws {Error} if no organization ID is provided when there is no current user
+   */
   public whoami = async (orgId = this.user?.orgId): Promise<User> => {
     if (this.user) {
       return this.user;
@@ -200,6 +227,12 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return this.user;
   };
 
+  /**
+   * Looks up information based on an email address.
+   *
+   * @param {string} email the email address to look up
+   * @returns {Promise<any>} the result of the lookup request
+   */
   public lookupUserByEmail = async (email: string) => {
     return this.request("/v1/lookup", { email });
   };
@@ -209,10 +242,10 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * For SignMessage or SignTypedData, the caller should hash the message before calling this method and pass
    * that result here.
    *
-   * @param msg the hex representation of the bytes to sign
-   * @returns the signature over the raw hex
+   * @param {Hex} msg the hex representation of the bytes to sign
+   * @returns {Promise<Hex>} the signature over the raw hex
    */
-  public signRawMessage = async (msg: Hex) => {
+  public signRawMessage = async (msg: Hex): Promise<Hex> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
     }
@@ -236,10 +269,23 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return signature;
   };
 
+  /**
+   * Returns the current user or null if no user is set.
+   *
+   * @returns {User | null} the current user object or null if no user is available
+   */
   public getUser = (): User | null => {
     return this.user ?? null;
   };
 
+  /**
+   * Sends a POST request to the given signer route with the specified body and returns the response.
+   * Not intended to be used directly, use the specific methods instead on the client instead.
+   *
+   * @param {SignerRoutes} route The route to which the request should be sent
+   * @param {SignerBody<R>} body The request body containing the data to be sent
+   * @returns {Promise<SignerResponse<R>>} A promise that resolves to the response from the signer
+   */
   public request = async <R extends SignerRoutes>(
     route: R,
     body: SignerBody<R>
@@ -356,6 +402,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return result;
   };
 
+  // eslint-disable-next-line eslint-rules/require-jsdoc-on-reexported-functions
   protected pollActivityCompletion = async <
     T extends keyof Awaited<
       ReturnType<(typeof this.turnkeyClient)["getActivity"]>

package/src/client/index.ts

@@ -40,6 +40,29 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
   private webauthnStamper: WebauthnStamper;
   iframeContainerId: string;
 
+  /**
+   * Initializes a new instance with the given parameters, setting up the connection, iframe configuration, and WebAuthn stamper.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   * ```
+   *
+   * @param {AlchemySignerClientParams} params the parameters required to initialize the client
+   * @param {ConnectionConfig} params.connection The connection details needed to connect to the service
+   * @param {{ iframeElementId?: string; iframeContainerId: string }} params.iframeConfig The configuration details for setting up the iframe stamper
+   * @param {string} params.rpId The relying party ID, defaulting to the current hostname if not provided
+   * @param {string} params.rootOrgId The root organization ID
+   */
   constructor(params: AlchemySignerClientParams) {
     const { connection, iframeConfig, rpId, rootOrgId } =
       AlchemySignerClientParamsSchema.parse(params);
@@ -64,7 +87,29 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     });
   }
 
-  public createAccount = async (params: CreateAccountParams) => {
+  /**
+   * Authenticates the user by either email or passkey account creation flow. Emits events during the process.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.createAccount({ type: "email", email: "you@mail.com" });
+   * ```
+   *
+   * @param {CreateAccountParams} params The parameters for creating an account, including the type (email or passkey) and additional details.
+   * @returns {Promise<SignupResponse>} A promise that resolves with the response object containing the account creation result.
+   */
+  createAccount = async (params: CreateAccountParams) => {
     this.eventEmitter.emit("authenticating");
     if (params.type === "email") {
       const { email, expirationSeconds } = params;
@@ -105,6 +150,29 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     return result;
   };
 
+  /**
+   * Begin authenticating a user with their email and an expiration time for the authentication request. Initializes the iframe stamper to get the target public key.
+   * This method sends an email to the user to complete their login
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.initEmailAuth({ email: "you@mail.com" });
+   * ```
+   *
+   * @param {Omit<EmailAuthParams, "targetPublicKey">} params The parameters for email authentication, excluding the target public key
+   * @returns {Promise<any>} The response from the authentication request
+   */
   public initEmailAuth = async (
     params: Omit<EmailAuthParams, "targetPublicKey">
   ) => {
@@ -120,6 +188,28 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     });
   };
 
+  /**
+   * Completes email auth for the user by injecting a credential bundle and retrieving the user information based on the provided organization ID. Emits events during the process.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.completeEmailAuth({ orgId: "user-org-id", bundle: "bundle-from-email" });
+   * ```
+   *
+   * @param {{ bundle: string; orgId: string }} config The configuration object for the authentication function containing the credential bundle to inject and the organization id associated with the user
+   * @returns {Promise<User>} A promise that resolves to the authenticated user information
+   */
   public completeEmailAuth = async ({
     bundle,
     orgId,
@@ -142,6 +232,28 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     return user;
   };
 
+  /**
+   * Asynchronously handles the authentication process using WebAuthn Stamper. If a user is provided, sets the user and returns it. Otherwise, retrieves the current user and initializes the WebAuthn stamper.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.lookupUserWithPasskey();
+   * ```
+   *
+   * @param {User} [user] An optional user object to authenticate
+   * @returns {Promise<User>} A promise that resolves to the authenticated user object
+   */
   public lookupUserWithPasskey = async (user: User | undefined = undefined) => {
     this.eventEmitter.emit("authenticating");
     await this.initWebauthnStamper(user);
@@ -157,6 +269,33 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     return result;
   };
 
+  /**
+   * Initiates the export of a wallet by creating an iframe stamper and calling the appropriate export function.
+   * The export can be based on a seed phrase or a private key.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.exportWallet({
+   *  iframeContainerId: "export-iframe-container",
+   * });
+   * ```
+   *
+   * @param {ExportWalletParams} config The parameters for exporting the wallet
+   * @param {string} config.iframeContainerId The ID of the container element that will hold the iframe stamper
+   * @param {string} [config.iframeElementId] Optional ID for the iframe element
+   * @returns {Promise<void>} A promise that resolves when the export process is complete
+   */
   public exportWallet = async ({
     iframeContainerId,
     iframeElementId = "turnkey-export-iframe",
@@ -181,6 +320,25 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     });
   };
 
+  /**
+   * Asynchronous function that clears the user and resets the iframe stamper.
+   *
+   * @example
+   * ```ts
+   * import { AlchemySignerWebClient } from "@account-kit/signer";
+   *
+   * const client = new AlchemySignerWebClient({
+   *  connection: {
+   *    apiKey: "your-api-key",
+   *  },
+   *  iframeConfig: {
+   *   iframeContainerId: "signer-iframe-container",
+   *  },
+   * });
+   *
+   * const account = await client.disconnect();
+   * ```
+   */
   public disconnect = async () => {
     this.user = undefined;
     this.iframeStamper.clear();