@account-kit/signer 4.35.0 → 4.36.0

package/src/base.ts

@@ -141,8 +141,8 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
               mfaRequired: false,
               mfaFactorId: undefined,
             },
-          } satisfies AlchemySignerStore)
-      )
+          }) satisfies AlchemySignerStore,
+      ),
     );
     // NOTE: it's important that the session manager share a client
     // with the signer. The SessionManager leverages the Signer's client
@@ -170,7 +170,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    */
   on = <E extends AlchemySignerEvent>(
     event: E,
-    listener: AlchemySignerEvents[E]
+    listener: AlchemySignerEvents[E],
   ) => {
     // NOTE: we're using zustand here to handle this because we are able to use the fireImmediately
     // option which deals with a possible race condition where the listener is added after the event
@@ -183,8 +183,8 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           (status) =>
             status === AlchemySignerStatus.CONNECTED &&
             (listener as AlchemySignerEvents["connected"])(
-              this.store.getState().user!
-            )
+              this.store.getState().user!,
+            ),
         );
       case "disconnected":
         return subscribeWithDelayedFireImmediately(
@@ -192,13 +192,13 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           ({ status }) => status,
           (status) =>
             status === AlchemySignerStatus.DISCONNECTED &&
-            (listener as AlchemySignerEvents["disconnected"])()
+            (listener as AlchemySignerEvents["disconnected"])(),
         );
       case "statusChanged":
         return subscribeWithDelayedFireImmediately(
           this.store,
           ({ status }) => status,
-          listener as AlchemySignerEvents["statusChanged"]
+          listener as AlchemySignerEvents["statusChanged"],
         );
       case "errorChanged":
         return subscribeWithDelayedFireImmediately(
@@ -206,8 +206,8 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           ({ error }) => error,
           (error) =>
             (listener as AlchemySignerEvents["errorChanged"])(
-              error ?? undefined
-            )
+              error ?? undefined,
+            ),
         );
       case "newUserSignup":
         return subscribeWithDelayedFireImmediately(
@@ -215,14 +215,14 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           ({ isNewUser }) => isNewUser,
           (isNewUser) => {
             if (isNewUser) (listener as AlchemySignerEvents["newUserSignup"])();
-          }
+          },
         );
       case "mfaStatusChanged":
         return subscribeWithDelayedFireImmediately(
           this.store,
           ({ mfaStatus }) => mfaStatus,
           (mfaStatus) =>
-            (listener as AlchemySignerEvents["mfaStatusChanged"])(mfaStatus)
+            (listener as AlchemySignerEvents["mfaStatusChanged"])(mfaStatus),
         );
       case "emailAuthLinkingRequired":
         return subscribeWithDelayedFireImmediately(
@@ -231,10 +231,10 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
           (authLinkingStatus) => {
             if (authLinkingStatus) {
               (listener as AlchemySignerEvents["emailAuthLinkingRequired"])(
-                authLinkingStatus.email
+                authLinkingStatus.email,
               );
             }
-          }
+          },
         );
       default:
         assertNever(event, `Unknown event type ${event}`);
@@ -337,7 +337,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         });
         throw error;
       });
-    }
+    },
   );
 
   private trackAuthenticateType = (params: AuthParams) => {
@@ -458,7 +458,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       const { address } = await this.inner.whoami();
 
       return address;
-    }
+    },
   );
 
   /**
@@ -529,16 +529,16 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    */
   signTypedData: <
     const TTypedData extends TypedData | Record<string, unknown>,
-    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData
+    TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
   >(
-    params: TypedDataDefinition<TTypedData, TPrimaryType>
+    params: TypedDataDefinition<TTypedData, TPrimaryType>,
   ) => Promise<Hex> = SignerLogger.profiled(
     "BaseAlchemySigner.signTypedData",
     async (params) => {
       const messageHash = hashTypedData(params);
 
       return this.inner.signRawMessage(messageHash);
-    }
+    },
   );
 
   /**
@@ -572,15 +572,16 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<string>} a promise that resolves to the serialized transaction with the signature
    */
   signTransaction: <
-    serializer extends SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,
-    transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]
+    serializer extends
+      SerializeTransactionFn<TransactionSerializable> = SerializeTransactionFn<TransactionSerializable>,
+    transaction extends Parameters<serializer>[0] = Parameters<serializer>[0],
   >(
     transaction: transaction,
     options?:
       | {
           serializer?: serializer | undefined;
         }
-      | undefined
+      | undefined,
   ) => Promise<
     IsNarrowable<
       TransactionSerialized<GetTransactionType<transaction>>,
@@ -594,13 +595,13 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       const serializeFn = args?.serializer ?? serializeTransaction;
       const serializedTx = serializeFn(tx);
       const signatureHex = await this.inner.signRawMessage(
-        keccak256(serializedTx)
+        keccak256(serializedTx),
       );
 
       const signature = this.unpackSignRawMessageBytes(signatureHex);
 
       return serializeFn(tx, signature);
-    }
+    },
   );
 
   /**
@@ -632,14 +633,13 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<SignedAuthorization<number>> | undefined} a promise that resolves to the authorization with the signature
    */
   signAuthorization: (
-    unsignedAuthorization: AuthorizationRequest<number>
+    unsignedAuthorization: AuthorizationRequest<number>,
   ) => Promise<SignedAuthorization<number>> = SignerLogger.profiled(
     "BaseAlchemySigner.signAuthorization",
     async (unsignedAuthorization) => {
       const hashedAuthorization = hashAuthorization(unsignedAuthorization);
-      const signedAuthorizationHex = await this.inner.signRawMessage(
-        hashedAuthorization
-      );
+      const signedAuthorizationHex =
+        await this.inner.signRawMessage(hashedAuthorization);
       const signature = this.unpackSignRawMessageBytes(signedAuthorizationHex);
       const { address, contractAddress, ...unsignedAuthorizationRest } =
         unsignedAuthorization;
@@ -649,7 +649,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         ...signature,
         address: address ?? contractAddress,
       };
-    }
+    },
   );
 
   /**
@@ -686,7 +686,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   private unpackSignRawMessageBytes = (
-    hex: `0x${string}`
+    hex: `0x${string}`,
   ): UnpackedSignature => {
     return {
       r: takeBytes(hex, { count: 32 }),
@@ -794,7 +794,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {boolean} true if the wallet was exported successfully
    */
   exportWallet: (
-    params: Parameters<(typeof this.inner)["exportWallet"]>[0]
+    params: Parameters<(typeof this.inner)["exportWallet"]>[0],
   ) => Promise<boolean> = async (params) => {
     return this.inner.exportWallet(params);
   };
@@ -836,9 +836,9 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       signMessage: (msg) => this.signMessage(msg.message),
       signTypedData: <
         const typedData extends TypedData | Record<string, unknown>,
-        primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+        primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
       >(
-        typedDataDefinition: TypedDataDefinition<typedData, primaryType>
+        typedDataDefinition: TypedDataDefinition<typedData, primaryType>,
       ) => this.signTypedData<typedData, primaryType>(typedDataDefinition),
       signTransaction: this.signTransaction,
     });
@@ -877,7 +877,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   private authenticateWithEmail = async (
-    params: Extract<AuthParams, { type: "email" }>
+    params: Extract<AuthParams, { type: "email" }>,
   ): Promise<User> => {
     if ("bundle" in params) {
       return this.completeEmailAuth(params);
@@ -887,7 +887,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       params.email,
       params.emailMode,
       params.multiFactors,
-      params.redirectParams
+      params.redirectParams,
     );
 
     this.setAwaitingEmailAuth({ orgId, otpId, isNewUser });
@@ -906,7 +906,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   private authenticateWithPasskey = async (
-    args: Extract<AuthParams, { type: "passkey" }>
+    args: Extract<AuthParams, { type: "passkey" }>,
   ): Promise<User> => {
     let user: User;
     const shouldCreateNew = async () => {
@@ -923,7 +923,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         args as Extract<
           AuthParams,
           { type: "passkey" } & ({ email: string } | { createNew: true })
-        >
+        >,
       );
       // account creation for passkeys returns the whoami response so we don't have to
       // call it again after signup
@@ -946,7 +946,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   private authenticateWithOauth = async (
-    args: Extract<AuthParams, { type: "oauth" }>
+    args: Extract<AuthParams, { type: "oauth" }>,
   ): Promise<User> => {
     this.store.setState({ authLinkingStatus: undefined });
     const params: OauthParams = {
@@ -965,7 +965,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   };
 
   private authenticateWithOtp = async (
-    args: Extract<AuthParams, { type: "otp" }>
+    args: Extract<AuthParams, { type: "otp" }>,
   ): Promise<User> => {
     const tempSession = this.sessionManager.getTemporarySession();
     const { orgId, isNewUser } = tempSession ?? {};
@@ -1059,7 +1059,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
 
   private handleMfaRequired(
     encryptedPayload: string,
-    multiFactors: MfaFactor[]
+    multiFactors: MfaFactor[],
   ) {
     // Store complete MFA context in the temporary session
     const tempSession = this.sessionManager.getTemporarySession();
@@ -1154,7 +1154,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
     email: string,
     emailMode?: EmailType,
     multiFactors?: VerifyMfaParams[],
-    redirectParams?: URLSearchParams
+    redirectParams?: URLSearchParams,
   ): Promise<{
     orgId: string;
     otpId?: string;
@@ -1193,7 +1193,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
   }
 
   private async completeEmailAuth(
-    params: Extract<AuthParams, { type: "email"; bundle: string }>
+    params: Extract<AuthParams, { type: "email"; bundle: string }>,
   ): Promise<User> {
     const temporarySession = params.orgId
       ? { orgId: params.orgId }
@@ -1307,12 +1307,12 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
    */
   verifyMfa: (
-    params: VerifyMfaParams
+    params: VerifyMfaParams,
   ) => Promise<{ multiFactors: MfaFactor[] }> = SignerLogger.profiled(
     "BaseAlchemySigner.verifyMfa",
     async (params) => {
       return this.inner.verifyMfa(params);
-    }
+    },
   );
 
   /**
@@ -1343,12 +1343,12 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<{ multiFactors: MfaFactor[] }>} A promise that resolves to the updated list of MFA factors
    */
   removeMfa: (
-    params: RemoveMfaParams
+    params: RemoveMfaParams,
   ) => Promise<{ multiFactors: MfaFactor[] }> = SignerLogger.profiled(
     "BaseAlchemySigner.removeMfa",
     async (params) => {
       return this.inner.removeMfa(params);
-    }
+    },
   );
 
   /**
@@ -1383,7 +1383,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
    * @returns {Promise<User>} A promise that resolves to the authenticated user
    */
   public async validateMultiFactors(
-    params: ValidateMultiFactorsArgs
+    params: ValidateMultiFactorsArgs,
   ): Promise<User> {
     // Get MFA context from temporary session
     const tempSession = this.sessionManager.getTemporarySession();
@@ -1393,7 +1393,7 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
       !tempSession.mfaFactorId
     ) {
       throw new Error(
-        "No pending MFA context found. Call submitOtpCode() first."
+        "No pending MFA context found. Call submitOtpCode() first.",
       );
     }
 
@@ -1518,22 +1518,43 @@ function toErrorInfo(error: unknown): ErrorInfo {
 function subscribeWithDelayedFireImmediately<T>(
   store: InternalStore,
   selector: (state: AlchemySignerStore) => T,
-  listener: (selectedState: T, previousSelectedState: T) => void
+  listener: (selectedState: T, previousSelectedState: T) => void,
 ): () => void {
-  let subscribeHasReturned = false;
+  // Until this function has returned, maintain a queue of events that will be
+  // processed once it does.
+  const queue: [selectedState: T, previousSelectedState: T][] = [];
+  let queueHasEmptied = false;
+  let hasUnsubscribed = false;
+
+  function drainQueue() {
+    // Note that this handles the case where more events are added to the queue
+    // during the handling of previous events.
+    for (let i = 0; i < queue.length && !hasUnsubscribed; i++) {
+      const args = queue[i];
+      listener(...args);
+    }
+    queueHasEmptied = true;
+  }
+
+  // Schedule the queue to be drained after this function has returned.
+  setTimeout(drainQueue, 0);
+
   const unsubscribe = store.subscribe(
     selector,
     (...args) => {
-      if (subscribeHasReturned) {
+      if (queueHasEmptied) {
         listener(...args);
       } else {
-        setTimeout(() => listener(...args), 0);
+        queue.push(args);
       }
     },
-    { fireImmediately: true }
+    { fireImmediately: true },
   );
-  subscribeHasReturned = true;
-  return unsubscribe;
+
+  return () => {
+    hasUnsubscribed = true;
+    unsubscribe();
+  };
 }
 
 function isAuthLinkingPrompt(result: unknown): result is AuthLinkingPrompt {

package/src/client/base.ts

@@ -82,7 +82,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     this.connectionConfig = ConnectionConfigSchema.parse(connection);
     this.turnkeyClient = new TurnkeyClient(
       { baseUrl: "https://api.turnkey.com" },
-      stamper
+      stamper,
     );
   }
 
@@ -145,11 +145,11 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   // #region ABSTRACT METHODS
 
   public abstract createAccount(
-    params: CreateAccountParams
+    params: CreateAccountParams,
   ): Promise<SignupResponse>;
 
   public abstract initEmailAuth(
-    params: Omit<EmailAuthParams, "targetPublicKey">
+    params: Omit<EmailAuthParams, "targetPublicKey">,
   ): Promise<{ orgId: string; otpId?: string; multiFactors?: MfaFactor[] }>;
 
   public abstract completeAuthWithBundle(params: {
@@ -161,15 +161,15 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   }): Promise<User>;
 
   public abstract oauthWithRedirect(
-    args: Extract<OauthParams, { mode: "redirect" }>
+    args: Extract<OauthParams, { mode: "redirect" }>,
   ): Promise<User>;
 
   public abstract oauthWithPopup(
-    args: Extract<OauthParams, { mode: "popup" }>
+    args: Extract<OauthParams, { mode: "popup" }>,
   ): Promise<User | AuthLinkingPrompt>;
 
   public abstract submitOtpCode(
-    args: Omit<OtpParams, "targetPublicKey">
+    args: Omit<OtpParams, "targetPublicKey">,
   ): Promise<SubmitOtpCodeResponse>;
 
   public abstract disconnect(): Promise<void>;
@@ -184,7 +184,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
 
   protected abstract getWebAuthnAttestation(
     options: CredentialCreationOptions,
-    userDetails?: { username: string }
+    userDetails?: { username: string },
   ): Promise<GetWebAuthnAttestationResult>;
 
   // #endregion
@@ -200,7 +200,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    */
   public on = <E extends AlchemySignerClientEvent>(
     event: E,
-    listener: AlchemySignerClientEvents[E]
+    listener: AlchemySignerClientEvents[E],
   ) => {
     this.eventEmitter.on(event, listener as any);
 
@@ -218,9 +218,8 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     if (!this.user) {
       throw new NotAuthenticatedError();
     }
-    const { attestation, challenge } = await this.getWebAuthnAttestation(
-      options
-    );
+    const { attestation, challenge } =
+      await this.getWebAuthnAttestation(options);
 
     const { activity } = await this.turnkeyClient.createAuthenticators({
       type: "ACTIVITY_TYPE_CREATE_AUTHENTICATORS_V2",
@@ -241,7 +240,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     const { authenticatorIds } = await this.pollActivityCompletion(
       activity,
       this.user.orgId,
-      "createAuthenticatorsResult"
+      "createAuthenticatorsResult",
     );
 
     return authenticatorIds;
@@ -263,7 +262,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     });
     return {
       isPasskeyAdded: resp.authenticators.some((it) =>
-        it.authenticatorName.startsWith("passkey-")
+        it.authenticatorName.startsWith("passkey-"),
       ),
     };
   };
@@ -276,7 +275,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @returns {Promise<void>} A Promise that resolves when the OAuth provider is added.
    */
   public addOauthProvider = async (
-    params: AddOauthProviderParams
+    params: AddOauthProviderParams,
   ): Promise<void> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
@@ -304,7 +303,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    */
   public whoami = async (
     orgId = this.user?.orgId,
-    idToken?: string
+    idToken?: string,
   ): Promise<User> => {
     if (this.user) {
       return this.user;
@@ -376,7 +375,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   public stampGetOrganization = async (): Promise<TSignedRequest> => {
     if (!this.user) {
       throw new Error(
-        "User must be authenticated to stamp a get organization request"
+        "User must be authenticated to stamp a get organization request",
       );
     }
 
@@ -396,7 +395,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @throws {Error} If there is no authenticated user or the API key creation fails.
    */
   public experimental_createApiKey = async (
-    params: experimental_CreateApiKeyParams
+    params: experimental_CreateApiKeyParams,
   ): Promise<void> => {
     if (!this.user) {
       throw new Error("User must be authenticated to create api key");
@@ -443,7 +442,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    */
   public signRawMessage = async (
     msg: Hex,
-    mode: "SOLANA" | "ETHEREUM" = "ETHEREUM"
+    mode: "SOLANA" | "ETHEREUM" = "ETHEREUM",
   ): Promise<Hex> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
@@ -496,7 +495,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    */
   public request = async <R extends SignerRoutes>(
     route: R,
-    body: SignerBody<R>
+    body: SignerBody<R>,
   ): Promise<SignerResponse<R>> => {
     const url = this.connectionConfig.rpcUrl ?? "https://api.g.alchemy.com";
 
@@ -589,7 +588,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
         });
       default:
         throw new Error(
-          `Unsupported MFA factor type: ${params.multiFactorType}`
+          `Unsupported MFA factor type: ${params.multiFactorType}`,
         );
     }
   };
@@ -602,7 +601,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @throws {NotAuthenticatedError} If no user is authenticated
    */
   public verifyMfa = async (
-    params: VerifyMfaParams
+    params: VerifyMfaParams,
   ): Promise<{ multiFactors: MfaFactor[] }> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
@@ -635,7 +634,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @throws {NotAuthenticatedError} If no user is authenticated
    */
   public removeMfa = async (
-    params: RemoveMfaParams
+    params: RemoveMfaParams,
   ): Promise<{ multiFactors: MfaFactor[] }> => {
     if (!this.user) {
       throw new NotAuthenticatedError();
@@ -667,7 +666,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @throws {Error} If no credential bundle is returned from the server
    */
   public validateMultiFactors = async (
-    params: ValidateMultiFactorsParams
+    params: ValidateMultiFactorsParams,
   ): Promise<{ bundle: string }> => {
     // Send the encryptedPayload plus TOTP codes, etc:
     const response = await this.request("/v1/auth-validate-multi-factors", {
@@ -678,7 +677,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     // The server is expected to return the *decrypted* payload in `response.payload.credentialBundle`
     if (!response.payload || !response.payload.credentialBundle) {
       throw new Error(
-        "Request to validateMultiFactors did not return a credential bundle"
+        "Request to validateMultiFactors did not return a credential bundle",
       );
     }
 
@@ -704,17 +703,17 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
         this.turnkeyClient.getWalletAccounts({
           organizationId: this.user!.orgId,
           walletId,
-        })
-      )
+        }),
+      ),
     ).then((x) => x.flatMap((x) => x.accounts));
 
     const walletAccount = walletAccounts.find(
-      (x) => x.address === this.user!.address
+      (x) => x.address === this.user!.address,
     );
 
     if (!walletAccount) {
       throw new Error(
-        `Could not find wallet associated with ${this.user.address}`
+        `Could not find wallet associated with ${this.user.address}`,
       );
     }
 
@@ -731,7 +730,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     const { exportBundle } = await this.pollActivityCompletion(
       activity,
       this.user.orgId,
-      "exportWalletResult"
+      "exportWalletResult",
     );
 
     const result = await stamper.injectWalletExportBundle(exportBundle);
@@ -761,7 +760,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     const { exportBundle } = await this.pollActivityCompletion(
       activity,
       this.user.orgId,
-      "exportWalletAccountResult"
+      "exportWalletAccountResult",
     );
 
     const result = await stamper.injectKeyExportBundle(exportBundle);
@@ -807,7 +806,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
    * @returns {Promise<string>} returns the Oauth provider's url
    */
   protected getOauthProviderUrl = async (
-    args: GetOauthProviderUrlArgs
+    args: GetOauthProviderUrlArgs,
   ): Promise<string> => {
     const {
       oauthParams,
@@ -839,7 +838,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     const authProvider = authProviders.find(
       (provider) =>
         provider.id === authProviderId &&
-        !!provider.isCustomProvider === !!isCustomProvider
+        !!provider.isCustomProvider === !!isCustomProvider,
     );
 
     if (!authProvider) {
@@ -879,7 +878,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
       openerOrigin: mode === "popup" ? window.location.origin : undefined,
     };
     const state = base64UrlEncode(
-      new TextEncoder().encode(JSON.stringify(stateObject))
+      new TextEncoder().encode(JSON.stringify(stateObject)),
     );
     const authUrl = new URL(authEndpoint);
     const params: Record<string, string> = {
@@ -911,7 +910,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   };
 
   private getOauthConfigForMode = async (
-    mode: OauthMode
+    mode: OauthMode,
   ): Promise<OauthConfig> => {
     if (this.oauthConfig) {
       return this.oauthConfig;
@@ -919,7 +918,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
       return this.initOauth();
     } else {
       throw new Error(
-        "enablePopupOauth must be set in configuration or signer.preparePopupOauth must be called before using popup-based OAuth login"
+        "enablePopupOauth must be set in configuration or signer.preparePopupOauth must be called before using popup-based OAuth login",
       );
     }
   };
@@ -928,13 +927,13 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
   protected pollActivityCompletion = async <
     T extends keyof Awaited<
       ReturnType<(typeof this.turnkeyClient)["getActivity"]>
-    >["activity"]["result"]
+    >["activity"]["result"],
   >(
     activity: Awaited<
       ReturnType<(typeof this.turnkeyClient)["getActivity"]>
     >["activity"],
     organizationId: string,
-    resultKey: T
+    resultKey: T,
   ): Promise<
     NonNullable<
       Awaited<
@@ -963,7 +962,7 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
       status === "ACTIVITY_STATUS_CONSENSUS_NEEDED"
     ) {
       throw new Error(
-        `Failed to get activity with with id ${id} (status: ${status})`
+        `Failed to get activity with with id ${id} (status: ${status})`,
       );
     }