@account-kit/signer 4.0.0-beta.8 → 4.0.0

package/src/base.ts

@@ -4,10 +4,14 @@ import {
   hashTypedData,
   keccak256,
   serializeTransaction,
-  type CustomSource,
+  type GetTransactionType,
   type Hex,
+  type IsNarrowable,
   type LocalAccount,
+  type SerializeTransactionFn,
   type SignableMessage,
+  type TransactionSerializable,
+  type TransactionSerialized,
   type TypedData,
   type TypedDataDefinition,
 } from "viem";
@@ -18,6 +22,7 @@ import { createStore } from "zustand/vanilla";
 import type { BaseSignerClient } from "./client/base";
 import type { OauthConfig, OauthParams, User } from "./client/types";
 import { NotAuthenticatedError } from "./errors.js";
+import { SignerLogger } from "./metrics.js";
 import {
   SessionManager,
   type SessionManagerParams,
@@ -27,17 +32,20 @@ import {
   AlchemySignerStatus,
   type AlchemySignerEvent,
   type AlchemySignerEvents,
+  type ErrorInfo,
 } from "./types.js";
 import { assertNever } from "./utils/typeAssertions.js";
 
 export interface BaseAlchemySignerParams<TClient extends BaseSignerClient> {
   client: TClient;
   sessionConfig?: Omit<SessionManagerParams, "client">;
+  initialError?: ErrorInfo;
 }
 
 type AlchemySignerStore = {
   user: User | null;
   status: AlchemySignerStatus;
+  error: ErrorInfo | null;
 };
 
 type InternalStore = Mutate<
@@ -65,8 +73,13 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @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
+   * @param {ErrorInfo | undefined} param0.initialError Error already present on the signer when initialized, if any
    */
-  constructor({ client, sessionConfig }: BaseAlchemySignerParams<TClient>) {
+  constructor({
+    client,
+    sessionConfig,
+    initialError,
+  }: BaseAlchemySignerParams<TClient>) {
     this.inner = client;
     this.store = createStore(
       subscribeWithSelector(
@@ -74,6 +87,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           ({
             user: null,
             status: AlchemySignerStatus.INITIALIZING,
+            error: initialError ?? null,
           } satisfies AlchemySignerStore)
       )
     );
@@ -84,15 +98,6 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       ...sessionConfig,
       client: this.inner,
     });
-    this.store = createStore(
-      subscribeWithSelector(
-        () =>
-          ({
-            user: null,
-            status: AlchemySignerStatus.INITIALIZING,
-          } satisfies AlchemySignerStore)
-      )
-    );
     // register listeners first
     this.registerListeners();
     // then initialize so that we can catch those events
@@ -138,8 +143,17 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           listener as AlchemySignerEvents["statusChanged"],
           { fireImmediately: true }
         );
+      case "errorChanged":
+        return this.store.subscribe(
+          ({ error }) => error,
+          (error) =>
+            (listener as AlchemySignerEvents["errorChanged"])(
+              error ?? undefined
+            ),
+          { fireImmediately: true }
+        );
       default:
-        throw new Error(`Unknown event type ${event}`);
+        assertNever(event, `Unknown event type ${event}`);
     }
   };
 
@@ -201,17 +215,78 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @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) => {
+  authenticate: (params: AuthParams) => Promise<User> = SignerLogger.profiled(
+    "BaseAlchemySigner.authenticate",
+    async (params) => {
+      const { type } = params;
+      const result = (() => {
+        switch (type) {
+          case "email":
+            return this.authenticateWithEmail(params);
+          case "passkey":
+            return this.authenticateWithPasskey(params);
+          case "oauth":
+            return this.authenticateWithOauth(params);
+          case "oauthReturn":
+            return this.handleOauthReturn(params);
+          default:
+            assertNever(type, `Unknown auth type: ${type}`);
+        }
+      })();
+
+      this.trackAuthenticateType(params);
+
+      return result.catch((error) => {
+        /**
+         * 2 things going on here:
+         * 1. for oauth flows we expect the status to remain in authenticating
+         * 2. we do the ternary, because if we explicitly pass in `undefined` for the status, zustand will set the value of status to `undefined`.
+         * However, if we omit it, then it will not override the current value of status.
+         */
+        this.store.setState({
+          error: toErrorInfo(error),
+          ...(type === "oauthReturn" || type === "oauth"
+            ? {}
+            : { status: AlchemySignerStatus.DISCONNECTED }),
+        });
+        throw error;
+      });
+    }
+  );
+
+  private trackAuthenticateType = (params: AuthParams) => {
     const { type } = params;
     switch (type) {
-      case "email":
-        return this.authenticateWithEmail(params);
-      case "passkey":
-        return this.authenticateWithPasskey(params);
+      case "email": {
+        // we just want to track the start of email auth
+        if ("bundle" in params) return;
+        SignerLogger.trackEvent({
+          name: "signer_authnticate",
+          data: { authType: "email" },
+        });
+        return;
+      }
+      case "passkey": {
+        const isAnon = !("email" in params) && params.createNew == null;
+        SignerLogger.trackEvent({
+          name: "signer_authnticate",
+          data: {
+            authType: isAnon ? "passkey_anon" : "passkey_email",
+          },
+        });
+        return;
+      }
       case "oauth":
-        return this.authenticateWithOauth(params);
+        SignerLogger.trackEvent({
+          name: "signer_authnticate",
+          data: {
+            authType: "oauth",
+            provider: params.authProviderId,
+          },
+        });
+        break;
       case "oauthReturn":
-        return this.handleOauthReturn(params);
+        break;
       default:
         assertNever(type, `Unknown auth type: ${type}`);
     }
@@ -285,11 +360,14 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    *
    * @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();
+  getAddress: () => Promise<`0x${string}`> = SignerLogger.profiled(
+    "BaseAlchemySigner.getAddress",
+    async () => {
+      const { address } = await this.inner.whoami();
 
-    return address;
-  };
+      return address;
+    }
+  );
 
   /**
    * Signs a raw message after hashing it.
@@ -315,13 +393,18 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @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
-  ) => {
-    const messageHash = hashMessage(msg);
+  signMessage: (msg: SignableMessage) => Promise<`0x${string}`> =
+    SignerLogger.profiled("BaseAlchemySigner.signMessage", async (msg) => {
+      const messageHash = hashMessage(msg);
 
-    return this.inner.signRawMessage(messageHash);
-  };
+      const result = await this.inner.signRawMessage(messageHash);
+
+      SignerLogger.trackEvent({
+        name: "signer_sign_message",
+      });
+
+      return result;
+    });
 
   /**
    * Signs a typed message by first hashing it and then signing the hashed message using the `signRawMessage` method.
@@ -357,11 +440,14 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
   >(
     params: TypedDataDefinition<TTypedData, TPrimaryType>
-  ) => Promise<Hex> = async (params) => {
-    const messageHash = hashTypedData(params);
+  ) => Promise<Hex> = SignerLogger.profiled(
+    "BaseAlchemySigner.signTypedData",
+    async (params) => {
+      const messageHash = hashTypedData(params);
 
-    return this.inner.signRawMessage(messageHash);
-  };
+      return this.inner.signRawMessage(messageHash);
+    }
+  );
 
   /**
    * Serializes a transaction, signs it with a raw message, and then returns the serialized transaction with the signature.
@@ -393,21 +479,41 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @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);
-    const signatureHex = await this.inner.signRawMessage(
-      keccak256(serializedTx)
-    );
+  signTransaction: <
+    serializer extends SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,
+    transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]
+  >(
+    transaction: transaction,
+    options?:
+      | {
+          serializer?: serializer | undefined;
+        }
+      | undefined
+  ) => Promise<
+    IsNarrowable<
+      TransactionSerialized<GetTransactionType<transaction>>,
+      Hex
+    > extends true
+      ? TransactionSerialized<GetTransactionType<transaction>>
+      : Hex
+  > = SignerLogger.profiled(
+    "BaseAlchemySigner.signTransaction",
+    async (tx, args) => {
+      const serializeFn = args?.serializer ?? serializeTransaction;
+      const serializedTx = serializeFn(tx);
+      const signatureHex = await this.inner.signRawMessage(
+        keccak256(serializedTx)
+      );
 
-    const signature = {
-      r: takeBytes(signatureHex, { count: 32 }),
-      s: takeBytes(signatureHex, { count: 32, offset: 32 }),
-      v: BigInt(takeBytes(signatureHex, { count: 1, offset: 64 })),
-    };
+      const signature = {
+        r: takeBytes(signatureHex, { count: 32 }),
+        s: takeBytes(signatureHex, { count: 32, offset: 32 }),
+        v: BigInt(takeBytes(signatureHex, { count: 1, offset: 64 })),
+      };
 
-    return serializeFn(tx, signature);
-  };
+      return serializeFn(tx, signature);
+    }
+  );
 
   /**
    * Unauthenticated call to look up a user's organizationId by email
@@ -433,19 +539,18 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @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
-  ) => {
-    const result = await this.inner.lookupUserByEmail(email);
+  getUser: (email: string) => Promise<{ orgId: string } | null> =
+    SignerLogger.profiled("BaseAlchemySigner.getUser", async (email) => {
+      const result = await this.inner.lookupUserByEmail(email);
 
-    if (result.orgId == null) {
-      return null;
-    }
+      if (result.orgId == null) {
+        return null;
+      }
 
-    return {
-      orgId: result.orgId,
-    };
-  };
+      return {
+        orgId: result.orgId,
+      };
+    });
 
   /**
    * Adds a passkey to the user's account
@@ -472,9 +577,9 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<string[]>} an array of the authenticator ids added to the user
    */
   addPasskey: (params?: CredentialCreationOptions) => Promise<string[]> =
-    async (params) => {
+    SignerLogger.profiled("BaseAlchemySigner.addPasskey", async (params) => {
       return this.inner.addPasskey(params ?? {});
-    };
+    });
 
   /**
    * Used to export the wallet for a given user
@@ -577,7 +682,10 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           });
 
       this.sessionManager.setTemporarySession({ orgId });
-      this.store.setState({ status: AlchemySignerStatus.AWAITING_EMAIL_AUTH });
+      this.store.setState({
+        status: AlchemySignerStatus.AWAITING_EMAIL_AUTH,
+        error: null,
+      });
 
       // We wait for the session manager to emit a connected event if
       // cross tab sessions are permitted
@@ -604,6 +712,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         bundle: params.bundle,
         orgId: temporarySession.orgId,
         connectedEventName: "connectedEmail",
+        authenticatingType: "email",
       });
 
       return user;
@@ -667,11 +776,14 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   private handleOauthReturn = ({
     bundle,
     orgId,
+    idToken,
   }: Extract<AuthParams, { type: "oauthReturn" }>): Promise<User> =>
     this.inner.completeAuthWithBundle({
       bundle,
       orgId,
       connectedEventName: "connectedOauth",
+      authenticatingType: "oauth",
+      idToken,
     });
 
   private registerListeners = () => {
@@ -679,6 +791,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       this.store.setState({
         user: session.user,
         status: AlchemySignerStatus.CONNECTED,
+        error: null,
       });
     });
 
@@ -694,11 +807,34 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         status: state.user
           ? AlchemySignerStatus.CONNECTED
           : AlchemySignerStatus.DISCONNECTED,
+        ...(state.user ? { error: null } : undefined),
       }));
     });
 
-    this.inner.on("authenticating", () => {
-      this.store.setState({ status: AlchemySignerStatus.AUTHENTICATING });
+    this.inner.on("authenticating", ({ type }) => {
+      const status = (() => {
+        switch (type) {
+          case "email":
+            return AlchemySignerStatus.AUTHENTICATING_EMAIL;
+          case "passkey":
+            return AlchemySignerStatus.AUTHENTICATING_PASSKEY;
+          case "oauth":
+            return AlchemySignerStatus.AUTHENTICATING_OAUTH;
+          default:
+            assertNever(type, "unhandled authenticating type");
+        }
+      })();
+
+      this.store.setState({
+        status,
+        error: null,
+      });
     });
   };
 }
+
+function toErrorInfo(error: unknown): ErrorInfo {
+  return error instanceof Error
+    ? { name: error.name, message: error.message }
+    : { name: "Error", message: "Unknown error" };
+}

package/src/client/base.ts

@@ -1,12 +1,15 @@
 import { ConnectionConfigSchema, type ConnectionConfig } from "@aa-sdk/core";
 import { TurnkeyClient, type TSignedRequest } from "@turnkey/http";
 import EventEmitter from "eventemitter3";
+import { jwtDecode } from "jwt-decode";
 import type { Hex } from "viem";
 import { NotAuthenticatedError } from "../errors.js";
 import { base64UrlEncode } from "../utils/base64UrlEncode.js";
+import { assertNever } from "../utils/typeAssertions.js";
 import type {
   AlchemySignerClientEvent,
   AlchemySignerClientEvents,
+  AuthenticatingEventMetadata,
   CreateAccountParams,
   EmailAuthParams,
   GetWebAuthnAttestationResult,
@@ -18,7 +21,6 @@ import type {
   SignupResponse,
   User,
 } from "./types.js";
-import { assertNever } from "../utils/typeAssertions.js";
 
 export interface BaseSignerClientParams {
   stamper: TurnkeyClient["stamper"];
@@ -130,6 +132,8 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     bundle: string;
     orgId: string;
     connectedEventName: keyof AlchemySignerClientEvents;
+    authenticatingType: AuthenticatingEventMetadata["type"];
+    idToken?: string;
   }): Promise<User>;
 
   public abstract oauthWithRedirect(
@@ -217,10 +221,14 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * 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
+   * @param {string} idToken an OIDC ID token containing additional user information
    * @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> => {
+  public whoami = async (
+    orgId = this.user?.orgId,
+    idToken?: string
+  ): Promise<User> => {
     if (this.user) {
       return this.user;
     }
@@ -237,6 +245,15 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
       stampedRequest,
     });
 
+    if (idToken) {
+      const claims: Record<string, unknown> = jwtDecode(idToken);
+      user.idToken = idToken;
+      user.claims = claims;
+      if (typeof claims.email === "string") {
+        user.email = claims.email;
+      }
+    }
+
     const credentialId = (() => {
       try {
         return JSON.parse(stampedRequest?.stamp.stampHeaderValue)

package/src/client/index.ts

@@ -3,11 +3,14 @@ import { getWebAuthnAttestation } from "@turnkey/http";
 import { IframeStamper } from "@turnkey/iframe-stamper";
 import { WebauthnStamper } from "@turnkey/webauthn-stamper";
 import { z } from "zod";
+import { getDefaultScopeAndClaims, getOauthNonce } from "../oauth.js";
+import type { AuthParams, OauthMode } from "../signer.js";
 import { base64UrlEncode } from "../utils/base64UrlEncode.js";
 import { generateRandomBuffer } from "../utils/generateRandomBuffer.js";
 import { BaseSignerClient } from "./base.js";
 import type {
   AlchemySignerClientEvents,
+  AuthenticatingEventMetadata,
   CreateAccountParams,
   CredentialCreationOptionOverrides,
   EmailAuthParams,
@@ -16,8 +19,6 @@ import type {
   OauthParams,
   User,
 } from "./types.js";
-import { getDefaultScopeAndClaims, getOauthNonce } from "../oauth.js";
-import type { AuthParams, OauthMode } from "../signer.js";
 
 const CHECK_CLOSE_INTERVAL = 500;
 
@@ -135,8 +136,8 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
    * @returns {Promise<SignupResponse>} A promise that resolves with the response object containing the account creation result.
    */
   public override createAccount = async (params: CreateAccountParams) => {
-    this.eventEmitter.emit("authenticating");
     if (params.type === "email") {
+      this.eventEmitter.emit("authenticating", { type: "email" });
       const { email, expirationSeconds } = params;
       const publicKey = await this.initIframeStamper();
 
@@ -150,6 +151,7 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
       return response;
     }
 
+    this.eventEmitter.emit("authenticating", { type: "passkey" });
     // Passkey account creation flow
     const { attestation, challenge } = await this.getWebAuthnAttestation(
       params.creationOpts,
@@ -202,7 +204,7 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
   public override initEmailAuth = async (
     params: Omit<EmailAuthParams, "targetPublicKey">
   ) => {
-    this.eventEmitter.emit("authenticating");
+    this.eventEmitter.emit("authenticating", { type: "email" });
     const { email, expirationSeconds } = params;
     const publicKey = await this.initIframeStamper();
 
@@ -215,7 +217,9 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
   };
 
   /**
-   * Completes 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.
+   * Completes 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
@@ -233,19 +237,28 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
    * const account = await client.completeAuthWithBundle({ orgId: "user-org-id", bundle: "bundle-from-email", connectedEventName: "connectedEmail" });
    * ```
    *
-   * @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
+   * @param {{ bundle: string; orgId: string, connectedEventName: keyof AlchemySignerClientEvents, idToken?: string }} config
+   * The configuration object for the authentication function containing the
+   * credential bundle to inject and the organization id associated with the
+   * user, as well as the event to be emitted on success and optionally an OIDC
+   * ID token with extra user information
+   * @returns {Promise<User>} A promise that resolves to the authenticated user
+   * information
    */
   public override completeAuthWithBundle = async ({
     bundle,
     orgId,
     connectedEventName,
+    idToken,
+    authenticatingType,
   }: {
     bundle: string;
     orgId: string;
     connectedEventName: keyof AlchemySignerClientEvents;
+    authenticatingType: AuthenticatingEventMetadata["type"];
+    idToken?: string;
   }): Promise<User> => {
-    this.eventEmitter.emit("authenticating");
+    this.eventEmitter.emit("authenticating", { type: authenticatingType });
     await this.initIframeStamper();
 
     const result = await this.iframeStamper.injectCredentialBundle(bundle);
@@ -254,7 +267,8 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
       throw new Error("Failed to inject credential bundle");
     }
 
-    const user = await this.whoami(orgId);
+    const user = await this.whoami(orgId, idToken);
+
     this.eventEmitter.emit(connectedEventName, user, bundle);
 
     return user;
@@ -285,7 +299,7 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
   public override lookupUserWithPasskey = async (
     user: User | undefined = undefined
   ) => {
-    this.eventEmitter.emit("authenticating");
+    this.eventEmitter.emit("authenticating", { type: "passkey" });
     await this.initWebauthnStamper(user);
     if (user) {
       this.user = user;
@@ -372,6 +386,7 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
   public override disconnect = async () => {
     this.user = undefined;
     this.iframeStamper.clear();
+    await this.iframeStamper.init();
   };
 
   /**
@@ -454,15 +469,18 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
         const {
           alchemyBundle: bundle,
           alchemyOrgId: orgId,
+          alchemyIdToken: idToken,
           alchemyError,
         } = event.data;
-        if (bundle && orgId) {
+        if (bundle && orgId && idToken) {
           cleanup();
           popup?.close();
           this.completeAuthWithBundle({
             bundle,
             orgId,
             connectedEventName: "connectedOauth",
+            idToken,
+            authenticatingType: "oauth",
           }).then(resolve, reject);
         } else if (alchemyError) {
           cleanup();

package/src/client/types.ts

@@ -14,6 +14,8 @@ export type User = {
   userId: string;
   address: Address;
   credentialId?: string;
+  idToken?: string;
+  claims?: Record<string, unknown>;
 };
 // [!endregion User]
 
@@ -134,9 +136,13 @@ export type SignerEndpoints = [
   }
 ];
 
+export type AuthenticatingEventMetadata = {
+  type: "email" | "passkey" | "oauth";
+};
+
 export type AlchemySignerClientEvents = {
   connected(user: User): void;
-  authenticating(): void;
+  authenticating(data: AuthenticatingEventMetadata): void;
   connectedEmail(user: User, bundle: string): void;
   connectedPasskey(user: User): void;
   connectedOauth(user: User, bundle: string): void;

package/src/metrics.ts

@@ -0,0 +1,23 @@
+import { createLogger } from "@account-kit/logging";
+import { VERSION } from "./version.js";
+
+export type SignerEventsSchema = [
+  {
+    EventName: "signer_authnticate";
+    EventData:
+      | {
+          authType: "email" | "passkey_anon" | "passkey_email" | "oauthReturn";
+          provider?: never;
+        }
+      | { authType: "oauth"; provider: string };
+  },
+  {
+    EventName: "signer_sign_message";
+    EventData: undefined;
+  }
+];
+
+export const SignerLogger = createLogger<SignerEventsSchema>({
+  package: "@account-kit/signer",
+  version: VERSION,
+});