@account-kit/signer 4.16.1-alpha.3 → 4.18.0-alpha.3

package/dist/esm/base.d.ts

@@ -12,6 +12,12 @@ export interface BaseAlchemySignerParams<TClient extends BaseSignerClient> {
     sessionConfig?: Omit<SessionManagerParams, "client">;
     initialError?: ErrorInfo;
 }
+export type EmailConfig = {
+    mode?: "MAGIC_LINK" | "OTP";
+};
+export type SignerConfig = {
+    email: EmailConfig;
+};
 /**
  * Base abstract class for Alchemy Signer, providing authentication and session management for smart accounts.
  * Implements the `SmartAccountAuthenticator` interface and handles various signer events.
@@ -21,6 +27,7 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
     inner: TClient;
     private sessionManager;
     private store;
+    private config;
     /**
      * Initializes an instance with the provided client and session configuration.
      * This function sets up the internal store, initializes the session manager,
@@ -274,36 +281,6 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
      * @returns {Promise<Authorization<number, true>> | undefined} a promise that resolves to the authorization with the signature
      */
     signAuthorization: (unsignedAuthorization: Authorization<number, false>) => Promise<Authorization<number, true>>;
-    /**
-     * Gets the current MFA status
-     *
-     * @example
-     * ```ts
-     * import { AlchemyWebSigner } from "@account-kit/signer";
-     *
-     * const signer = new AlchemyWebSigner({
-     *  client: {
-     *    connection: {
-     *      rpcUrl: "/api/rpc",
-     *    },
-     *    iframeConfig: {
-     *      iframeContainerId: "alchemy-signer-iframe-container",
-     *    },
-     *  },
-     * });
-     *
-     * const mfaStatus = signer.getMfaStatus();
-     * if (mfaStatus === AlchemyMfaStatus.REQUIRED) {
-     *   // Handle MFA requirement
-     * }
-     * ```
-     *
-     * @returns {{ mfaRequired: boolean; mfaFactorId?: string }} The current MFA status
-     */
-    getMfaStatus: () => {
-        mfaRequired: boolean;
-        mfaFactorId?: string;
-    };
     private unpackSignRawMessageBytes;
     /**
      * Unauthenticated call to look up a user's organizationId by email
@@ -439,11 +416,18 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
     private authenticateWithEmail;
     private authenticateWithPasskey;
     private authenticateWithOauth;
+    private authenticateWithJwt;
     private authenticateWithOtp;
     private handleOauthReturn;
     private getExpirationSeconds;
     private registerListeners;
     private emitNewUserEvent;
-    private initOrCreateEmailUser;
-    private completeEmailAuth;
+    protected initConfig: () => Promise<SignerConfig>;
+    /**
+     * Returns the signer configuration while fetching it if it's not already initialized.
+     *
+     * @returns {Promise<SignerConfig>} A promise that resolves to the signer configuration
+     */
+    getConfig: () => Promise<SignerConfig>;
+    protected fetchConfig: () => Promise<SignerConfig>;
 }

package/dist/esm/base.js

@@ -50,6 +50,12 @@ export class BaseAlchemySigner {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         /**
          * Allows you to subscribe to events emitted by the signer
          *
@@ -81,8 +87,6 @@ export class BaseAlchemySigner {
                             if (isNewUser)
                                 listener();
                         }, { fireImmediately: true });
-                    case "mfaStatusChanged":
-                        return this.store.subscribe(({ mfaStatus }) => mfaStatus, (mfaStatus) => listener(mfaStatus), { fireImmediately: true });
                     default:
                         assertNever(event, `Unknown event type ${event}`);
                 }
@@ -168,6 +172,8 @@ export class BaseAlchemySigner {
                             return this.handleOauthReturn(params);
                         case "otp":
                             return this.authenticateWithOtp(params);
+                        case "custom-jwt":
+                            return this.authenticateWithJwt(params);
                         default:
                             assertNever(type, `Unknown auth type: ${type}`);
                     }
@@ -217,6 +223,16 @@ export class BaseAlchemySigner {
                         });
                         return;
                     }
+                    case "custom-jwt": {
+                        SignerLogger.trackEvent({
+                            name: "signer_authnticate",
+                            data: {
+                                authType: "custom-jwt",
+                                provider: params.authProviderId,
+                            },
+                        });
+                        return;
+                    }
                     case "oauth":
                         SignerLogger.trackEvent({
                             name: "signer_authnticate",
@@ -479,40 +495,6 @@ export class BaseAlchemySigner {
                 return { ...unsignedAuthorization, ...signature };
             })
         });
-        /**
-         * Gets the current MFA status
-         *
-         * @example
-         * ```ts
-         * import { AlchemyWebSigner } from "@account-kit/signer";
-         *
-         * const signer = new AlchemyWebSigner({
-         *  client: {
-         *    connection: {
-         *      rpcUrl: "/api/rpc",
-         *    },
-         *    iframeConfig: {
-         *      iframeContainerId: "alchemy-signer-iframe-container",
-         *    },
-         *  },
-         * });
-         *
-         * const mfaStatus = signer.getMfaStatus();
-         * if (mfaStatus === AlchemyMfaStatus.REQUIRED) {
-         *   // Handle MFA requirement
-         * }
-         * ```
-         *
-         * @returns {{ mfaRequired: boolean; mfaFactorId?: string }} The current MFA status
-         */
-        Object.defineProperty(this, "getMfaStatus", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => {
-                return this.store.getState().mfaStatus;
-            }
-        });
         Object.defineProperty(this, "unpackSignRawMessageBytes", {
             enumerable: true,
             configurable: true,
@@ -713,36 +695,61 @@ export class BaseAlchemySigner {
             configurable: true,
             writable: true,
             value: async (params) => {
-                if ("bundle" in params) {
-                    return this.completeEmailAuth(params);
-                }
-                if (!("email" in params)) {
-                    throw new Error("Email is required");
+                if ("email" in params) {
+                    const existingUser = await this.getUser(params.email);
+                    const expirationSeconds = this.getExpirationSeconds();
+                    const { orgId, otpId } = existingUser
+                        ? await this.inner.initEmailAuth({
+                            email: params.email,
+                            emailMode: params.emailMode,
+                            expirationSeconds,
+                            redirectParams: params.redirectParams,
+                        })
+                        : await this.inner.createAccount({
+                            type: "email",
+                            email: params.email,
+                            emailMode: params.emailMode,
+                            expirationSeconds,
+                            redirectParams: params.redirectParams,
+                        });
+                    this.sessionManager.setTemporarySession({
+                        orgId,
+                        isNewUser: !existingUser,
+                    });
+                    this.store.setState({
+                        status: AlchemySignerStatus.AWAITING_EMAIL_AUTH,
+                        otpId,
+                        error: null,
+                    });
+                    // We wait for the session manager to emit a connected event if
+                    // cross tab sessions are permitted
+                    return new Promise((resolve) => {
+                        const removeListener = this.sessionManager.on("connected", (session) => {
+                            resolve(session.user);
+                            removeListener();
+                        });
+                    });
                 }
-                const { orgId, otpId, multiFactors, isNewUser } = await this.initOrCreateEmailUser(params.email, params.emailMode ?? "otp", params.multiFactors, params.redirectParams);
-                const isMfaRequired = multiFactors ? multiFactors?.length > 0 : false;
-                this.sessionManager.setTemporarySession({
-                    orgId,
-                    isNewUser,
-                    isMfaRequired,
-                });
-                this.store.setState({
-                    status: AlchemySignerStatus.AWAITING_EMAIL_AUTH,
-                    otpId,
-                    error: null,
-                    mfaStatus: {
-                        mfaRequired: isMfaRequired,
-                        mfaFactorId: multiFactors?.[0]?.multiFactorId,
-                    },
-                });
-                // We wait for the session manager to emit a connected event if
-                // cross tab sessions are permitted
-                return new Promise((resolve) => {
-                    const removeListener = this.sessionManager.on("connected", (session) => {
-                        resolve(session.user);
-                        removeListener();
+                else {
+                    const temporarySession = params.orgId
+                        ? { orgId: params.orgId }
+                        : this.sessionManager.getTemporarySession();
+                    if (!temporarySession) {
+                        this.store.setState({
+                            status: AlchemySignerStatus.DISCONNECTED,
+                        });
+                        throw new Error("Could not find email auth init session!");
+                    }
+                    const user = await this.inner.completeAuthWithBundle({
+                        bundle: params.bundle,
+                        orgId: temporarySession.orgId,
+                        connectedEventName: "connectedEmail",
+                        authenticatingType: "email",
                     });
-                });
+                    // fire new user event
+                    this.emitNewUserEvent(params.isNewUser);
+                    return user;
+                }
             }
         });
         Object.defineProperty(this, "authenticateWithPasskey", {
@@ -797,13 +804,32 @@ export class BaseAlchemySigner {
                 }
             }
         });
+        Object.defineProperty(this, "authenticateWithJwt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (args) => {
+                const { credentialBundle, orgId, isSignUp } = await this.inner.submitJwt({
+                    jwt: args.jwt,
+                    authProvider: args.authProviderId,
+                });
+                const user = await this.inner.completeAuthWithBundle({
+                    bundle: credentialBundle,
+                    orgId: orgId,
+                    connectedEventName: "connectedJwt",
+                    authenticatingType: "custom-jwt",
+                });
+                this.emitNewUserEvent(isSignUp);
+                return user;
+            }
+        });
         Object.defineProperty(this, "authenticateWithOtp", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: async (args) => {
                 const tempSession = this.sessionManager.getTemporarySession();
-                const { orgId, isNewUser, isMfaRequired } = tempSession ?? {};
+                const { orgId, isNewUser } = tempSession ?? {};
                 const { otpId } = this.store.getState();
                 if (!orgId) {
                     throw new Error("orgId not found in session");
@@ -811,15 +837,11 @@ export class BaseAlchemySigner {
                 if (!otpId) {
                     throw new Error("otpId not found in session");
                 }
-                if (isMfaRequired && !args.multiFactors) {
-                    throw new Error(`MFA is required.`);
-                }
                 const { bundle } = await this.inner.submitOtpCode({
                     orgId,
                     otpId,
                     otpCode: args.otpCode,
                     expirationSeconds: this.getExpirationSeconds(),
-                    multiFactors: args.multiFactors,
                 });
                 const user = await this.inner.completeAuthWithBundle({
                     bundle,
@@ -904,6 +926,8 @@ export class BaseAlchemySigner {
                             case "otp":
                             case "otpVerify":
                                 return AlchemySignerStatus.AWAITING_OTP_AUTH;
+                            case "custom-jwt":
+                                return AlchemySignerStatus.AUTHENTICATING_JWT;
                             default:
                                 assertNever(type, "unhandled authenticating type");
                         }
@@ -929,15 +953,44 @@ export class BaseAlchemySigner {
                     this.store.setState({ isNewUser });
             }
         });
+        Object.defineProperty(this, "initConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                this.config = this.fetchConfig();
+                return this.config;
+            }
+        });
+        /**
+         * Returns the signer configuration while fetching it if it's not already initialized.
+         *
+         * @returns {Promise<SignerConfig>} A promise that resolves to the signer configuration
+         */
+        Object.defineProperty(this, "getConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                if (!this.config) {
+                    return this.initConfig();
+                }
+                return this.config;
+            }
+        });
+        Object.defineProperty(this, "fetchConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async () => {
+                return this.inner.request("/v1/signer-config", {});
+            }
+        });
         this.inner = client;
         this.store = createStore(subscribeWithSelector(() => ({
             user: null,
             status: AlchemySignerStatus.INITIALIZING,
             error: initialError ?? null,
-            mfaStatus: {
-                mfaRequired: false,
-                mfaFactorId: undefined,
-            },
         })));
         // NOTE: it's important that the session manager share a client
         // with the signer. The SessionManager leverages the Signer's client
@@ -950,55 +1003,7 @@ export class BaseAlchemySigner {
         this.registerListeners();
         // then initialize so that we can catch those events
         this.sessionManager.initialize();
-    }
-    async initOrCreateEmailUser(email, emailMode, multiFactors, redirectParams) {
-        const existingUser = await this.getUser(email);
-        const expirationSeconds = this.getExpirationSeconds();
-        if (existingUser) {
-            const { orgId, otpId, multiFactors: mfaFactors, } = await this.inner.initEmailAuth({
-                email: email,
-                emailMode: emailMode,
-                expirationSeconds,
-                redirectParams: redirectParams,
-                multiFactors,
-            });
-            return {
-                orgId,
-                otpId,
-                multiFactors: mfaFactors,
-                isNewUser: false,
-            };
-        }
-        const { orgId, otpId } = await this.inner.createAccount({
-            type: "email",
-            email,
-            emailMode,
-            expirationSeconds,
-            redirectParams,
-        });
-        return {
-            orgId,
-            otpId,
-            isNewUser: true,
-        };
-    }
-    async completeEmailAuth(params) {
-        const temporarySession = params.orgId
-            ? { orgId: params.orgId }
-            : this.sessionManager.getTemporarySession();
-        if (!temporarySession) {
-            this.store.setState({ status: AlchemySignerStatus.DISCONNECTED });
-            throw new Error("Could not find email auth init session!");
-        }
-        const user = await this.inner.completeAuthWithBundle({
-            bundle: params.bundle,
-            orgId: temporarySession.orgId,
-            connectedEventName: "connectedEmail",
-            authenticatingType: "email",
-        });
-        // fire new user event
-        this.emitNewUserEvent(params.isNewUser);
-        return user;
+        this.config = this.fetchConfig();
     }
 }
 function toErrorInfo(error) {