@account-kit/signer 4.52.4 → 4.53.0

package/dist/esm/base.d.ts

@@ -18,6 +18,13 @@ export type EmailConfig = {
 export type SignerConfig = {
     email: EmailConfig;
 };
+type GetUserParams = {
+    type: "email";
+    value: string;
+} | {
+    type: "phone";
+    value: string;
+};
 /**
  * Base abstract class for Alchemy Signer, providing authentication and session management for smart accounts.
  * Implements the `SmartAccountAuthenticator` interface and handles various signer events.
@@ -315,6 +322,8 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
     /**
      * Unauthenticated call to look up a user's organizationId by email
      *
+     * @deprecated Use getUser({ type: "email", value: email }) instead
+     *
      * @example
      * ```ts
      * import { AlchemyWebSigner } from "@account-kit/signer";
@@ -336,7 +345,34 @@ export declare 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<{
+    getUser(email: string): Promise<{
+        orgId: string;
+    } | null>;
+    /**
+     * Unauthenticated call to look up a user's organizationId by email or phone
+     *
+     * @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({ type: "email", value: "foo@mail.com" });
+     * ```
+     *
+     * @param {string} email the email to lookup
+     * @returns {Promise<{orgId: string}>} the organization id for the user if they exist
+     */
+    getUser(params: GetUserParams): Promise<{
         orgId: string;
     } | null>;
     setEmail: (email: string) => Promise<void>;
@@ -483,6 +519,7 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
      */
     toSolanaSigner: () => SolanaSigner;
     private authenticateWithEmail;
+    private authenticateWithSms;
     private authenticateWithPasskey;
     private authenticateWithOauth;
     /**
@@ -511,12 +548,14 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
     listAuthMethods: () => Promise<AuthMethods>;
     private authenticateWithOtp;
     private setAwaitingEmailAuth;
+    private setAwaitingSmsAuth;
     private handleOauthReturn;
     private handleMfaRequired;
     private getExpirationSeconds;
     private registerListeners;
     private emitNewUserEvent;
     private initOrCreateEmailUser;
+    private initOrCreateSmsUser;
     private completeEmailAuth;
     /**
      * Retrieves the list of MFA factors configured for the current user.
@@ -677,3 +716,4 @@ export declare abstract class BaseAlchemySigner<TClient extends BaseSignerClient
     private setAuthLinkingPrompt;
     private waitForConnected;
 }
+export {};

package/dist/esm/base.js

@@ -173,6 +173,8 @@ export class BaseAlchemySigner {
                     switch (type) {
                         case "email":
                             return this.authenticateWithEmail(params);
+                        case "sms":
+                            return this.authenticateWithSms(params);
                         case "passkey":
                             return this.authenticateWithPasskey(params);
                         case "oauth":
@@ -220,6 +222,14 @@ export class BaseAlchemySigner {
                         });
                         return;
                     }
+                    case "sms": {
+                        // we just want to track the start of phone auth
+                        SignerLogger.trackEvent({
+                            name: "signer_authnticate",
+                            data: { authType: "sms" },
+                        });
+                        return;
+                    }
                     case "passkey": {
                         const isAnon = !("email" in params) && params.createNew == null;
                         SignerLogger.trackEvent({
@@ -543,44 +553,6 @@ export class BaseAlchemySigner {
                 };
             }
         });
-        /**
-         * Unauthenticated call to look up a user's organizationId by email
-         *
-         * @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
-         */
-        Object.defineProperty(this, "getUser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: SignerLogger.profiled("BaseAlchemySigner.getUser", async (email) => {
-                const result = await this.inner.lookupUserByEmail(email);
-                if (result.orgId == null) {
-                    return null;
-                }
-                return {
-                    orgId: result.orgId,
-                };
-            })
-        });
         /*
          * Sets the email for the authenticated user, allowing them to login with that
          * email.
@@ -825,6 +797,26 @@ export class BaseAlchemySigner {
                 return this.waitForConnected();
             }
         });
+        Object.defineProperty(this, "authenticateWithSms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: async (params) => {
+                const { orgId, otpId, isNewUser } = await this.initOrCreateSmsUser(params.phone);
+                this.setAwaitingSmsAuth({ orgId, otpId, isNewUser });
+                // TODO: add phone auth linking
+                // // Clear the auth linking status if the email has changed. This would mean
+                // // that the previously initiated social login is not associated with the
+                // // email which is now being used to login.
+                // const { authLinkingStatus } = this.store.getState();
+                // if (authLinkingStatus && authLinkingStatus.email !== params.email) {
+                //   this.store.setState({ authLinkingStatus: undefined });
+                // }
+                // We wait for the session manager to emit a connected event if
+                // cross tab sessions are permitted
+                return this.waitForConnected();
+            }
+        });
         Object.defineProperty(this, "authenticateWithPasskey", {
             enumerable: true,
             configurable: true,
@@ -833,7 +825,10 @@ export class BaseAlchemySigner {
                 let user;
                 const shouldCreateNew = async () => {
                     if ("email" in args) {
-                        const existingUser = await this.getUser(args.email);
+                        const existingUser = await this.getUser({
+                            type: "email",
+                            value: args.email,
+                        });
                         return existingUser == null;
                     }
                     return args.createNew;
@@ -1019,6 +1014,22 @@ export class BaseAlchemySigner {
                 });
             }
         });
+        Object.defineProperty(this, "setAwaitingSmsAuth", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ({ orgId, otpId, isNewUser, }) => {
+                this.sessionManager.setTemporarySession({
+                    orgId,
+                    isNewUser,
+                });
+                this.store.setState({
+                    status: AlchemySignerStatus.AWAITING_SMS_AUTH,
+                    otpId,
+                    error: null,
+                });
+            }
+        });
         Object.defineProperty(this, "handleOauthReturn", {
             enumerable: true,
             configurable: true,
@@ -1086,6 +1097,8 @@ export class BaseAlchemySigner {
                             case "otp":
                             case "otpVerify":
                                 return AlchemySignerStatus.AWAITING_OTP_AUTH;
+                            case "sms":
+                                return AlchemySignerStatus.AWAITING_SMS_AUTH;
                             default:
                                 assertNever(type, "unhandled authenticating type");
                         }
@@ -1340,6 +1353,48 @@ export class BaseAlchemySigner {
             this.setAuthLinkingPrompt(initialAuthLinkingPrompt);
         }
     }
+    /**
+     * Unauthenticated call to look up a user's organizationId by email or phone
+     *
+     * @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({ type: "email", value: "foo@mail.com" });
+     * ```
+     *
+     * @param {string | GetUserParams} params the params to look up
+     * @returns {Promise<{orgId: string}>} the organization id for the user if they exist
+     */
+    getUser(params) {
+        return SignerLogger.profiled("BaseAlchemySigner.getUser", async (params) => {
+            const _params = typeof params === "string"
+                ? { type: "email", value: params }
+                : params;
+            const result = _params.type === "email"
+                ? await this.inner.lookupUserByEmail(_params.value)
+                : _params.type === "phone"
+                    ? await this.inner.lookupUserByPhone(_params.value)
+                    : assertNever(_params, "unhandled get user params");
+            if (result?.orgId == null) {
+                return null;
+            }
+            return {
+                orgId: result.orgId,
+            };
+        })(params);
+    }
     handleMfaRequired(encryptedPayload, multiFactors) {
         // Store complete MFA context in the temporary session
         const tempSession = this.sessionManager.getTemporarySession();
@@ -1390,6 +1445,28 @@ export class BaseAlchemySigner {
             isNewUser: true,
         };
     }
+    async initOrCreateSmsUser(phone) {
+        const existingUser = await this.getUser({ type: "phone", value: phone });
+        if (existingUser) {
+            const { orgId, otpId } = await this.inner.initSmsAuth({
+                phone,
+            });
+            return {
+                orgId,
+                otpId,
+                isNewUser: false,
+            };
+        }
+        const { orgId, otpId } = await this.inner.createAccount({
+            type: "sms",
+            phone,
+        });
+        return {
+            orgId,
+            otpId,
+            isNewUser: true,
+        };
+    }
     async completeEmailAuth(params) {
         const temporarySession = params.orgId
             ? { orgId: params.orgId }