@account-kit/signer 4.52.4 → 4.53.1-alpha.0

package/src/client/base.ts

@@ -47,6 +47,7 @@ import type {
   OauthProviderInfo,
   IdTokenOnly,
   AuthMethods,
+  SmsAuthParams,
 } from "./types.js";
 import { VERSION } from "../version.js";
 import { secp256k1 } from "@noble/curves/secp256k1";
@@ -182,6 +183,18 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
       return response;
     }
 
+    if (params.type === "sms") {
+      this.eventEmitter.emit("authenticating", { type: "otp" });
+      const { phone } = params;
+      const publicKey = await this.initSessionStamper();
+
+      const response = await this.request("/v1/signup", {
+        phone,
+        targetPublicKey: publicKey,
+      });
+      return response;
+    }
+
     this.eventEmitter.emit("authenticating", { type: "passkey" });
     // Passkey account creation flow
     const { attestation, challenge } = await this.getWebAuthnAttestation(
@@ -218,6 +231,10 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     params: Omit<EmailAuthParams, "targetPublicKey">,
   ): Promise<{ orgId: string; otpId?: string; multiFactors?: MfaFactor[] }>;
 
+  public abstract initSmsAuth(
+    params: Omit<SmsAuthParams, "targetPublicKey">,
+  ): Promise<{ orgId: string; otpId?: string }>;
+
   public abstract completeAuthWithBundle(params: {
     bundle: string;
     orgId: string;
@@ -645,6 +662,16 @@ export abstract class BaseSignerClient<TExportWalletParams = unknown> {
     return this.request("/v1/lookup", { email });
   };
 
+  /**
+   * Looks up information based on a phone number.
+   *
+   * @param {string} phone the phone number to look up
+   * @returns {Promise<any>} the result of the lookup request
+   */
+  public lookupUserByPhone = async (phone: string) => {
+    return this.request("/v1/lookup", { phone });
+  };
+
   /**
    * This will sign a message with the user's private key, without doing any transformations on the message.
    * For SignMessage or SignTypedData, the caller should hash the message before calling this method and pass

package/src/client/index.ts

@@ -19,6 +19,7 @@ import type {
   AuthLinkingPrompt,
   GetWebAuthnAttestationResult,
   IdTokenOnly,
+  SmsAuthParams,
 } from "./types.js";
 import { MfaRequiredError } from "../errors.js";
 import { parseMfaError } from "../utils/parseMfaError.js";
@@ -160,6 +161,42 @@ export class AlchemySignerWebClient extends BaseSignerClient<ExportWalletParams>
     }
   };
 
+  /**
+   * Begin authenticating a user through sms. Initializes the iframe stamper to get the target public key.
+   * This method sends a text message 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.initSmsAuth({ phone: "+1234567890" });
+   * ```
+   *
+   * @param {Omit<SmsAuthParams, "targetPublicKey">} params The parameters for sms authentication, excluding the target public key
+   * @returns {Promise<any>} The response from the authentication request
+   */
+  public override initSmsAuth = async (
+    params: Omit<SmsAuthParams, "targetPublicKey">,
+  ) => {
+    this.eventEmitter.emit("authenticating", { type: "otp" });
+    const { phone } = params;
+    const publicKey = await this.initSessionStamper();
+
+    return this.request("/v1/auth", {
+      phone,
+      targetPublicKey: publicKey,
+    });
+  };
+
   /**
    * Authenticates using an OTP code which was previously received via email.
    *

package/src/client/types.ts

@@ -38,6 +38,10 @@ export type CreateAccountParams =
       expirationSeconds?: number;
       redirectParams?: URLSearchParams;
     }
+  | {
+      type: "sms";
+      phone: string;
+    }
   | {
       type: "passkey";
       email: string;
@@ -61,6 +65,11 @@ export type EmailAuthParams = {
   multiFactors?: VerifyMfaParams[];
 };
 
+export type SmsAuthParams = {
+  phone: string;
+  targetPublicKey: string;
+};
+
 export type OauthParams = Extract<AuthParams, { type: "oauth" }> & {
   expirationSeconds?: number;
   fetchIdTokenOnly?: boolean;
@@ -131,6 +140,7 @@ export type SignerEndpoints = [
       | (Omit<EmailAuthParams, "redirectParams"> & {
           redirectParams?: string;
         })
+      | SmsAuthParams
       | {
           passkey: {
             challenge: string;
@@ -148,10 +158,12 @@ export type SignerEndpoints = [
   },
   {
     Route: "/v1/auth";
-    Body: Omit<EmailAuthParams, "redirectParams"> & {
-      redirectParams?: string;
-      multiFactors?: VerifyMfaParams[];
-    };
+    Body:
+      | (Omit<EmailAuthParams, "redirectParams"> & {
+          redirectParams?: string;
+          multiFactors?: VerifyMfaParams[];
+        })
+      | SmsAuthParams;
     Response: {
       orgId: string;
       otpId?: string;
@@ -161,7 +173,8 @@ export type SignerEndpoints = [
   {
     Route: "/v1/lookup";
     Body: {
-      email: string;
+      email?: string;
+      phone?: string;
     };
     Response: {
       orgId: string | null;
@@ -334,7 +347,7 @@ export type SignerEndpoints = [
 ];
 
 export type AuthenticatingEventMetadata = {
-  type: "email" | "passkey" | "oauth" | "otp" | "otpVerify";
+  type: "email" | "passkey" | "oauth" | "otp" | "otpVerify" | "sms";
 };
 
 export type AlchemySignerClientEvents = {

package/src/index.ts

@@ -21,3 +21,7 @@ export type * from "./solanaSigner.js";
 export type * from "./types.js";
 export { AlchemySignerStatus } from "./types.js";
 export { SolanaSigner } from "./solanaSigner.js";
+export {
+  createSolanaSponsoredTransaction,
+  createSolanaTransaction,
+} from "./utils/solana.js";

package/src/metrics.ts

@@ -8,6 +8,7 @@ export type SignerEventsSchema = [
       | {
           authType:
             | "email"
+            | "sms"
             | "passkey_anon"
             | "passkey_email"
             | "otp"

package/src/signer.ts

@@ -21,6 +21,10 @@ export type AuthParams =
       multiFactors?: VerifyMfaParams[];
     }
   | { type: "email"; bundle: string; orgId?: string; isNewUser?: boolean }
+  | {
+      type: "sms";
+      phone: string;
+    }
   | {
       type: "passkey";
       email: string;

package/src/solanaSigner.ts

@@ -9,6 +9,7 @@ import {
 import { size, slice, toBytes, toHex, type ByteArray, type Hex } from "viem";
 import type { BaseSignerClient } from "./client/base";
 import { NotAuthenticatedError } from "./errors.js";
+import { createSolanaSponsoredTransaction } from "./utils/solana.js";
 
 /**
  * The SolanaSigner class is used to sign transactions and messages for the Solana blockchain.
@@ -159,53 +160,11 @@ export class SolanaSigner {
     connection: Connection,
     policyId: string,
   ): Promise<VersionedTransaction> {
-    const { blockhash } = await connection.getLatestBlockhash({
-      commitment: "finalized",
-    });
-    const message = new TransactionMessage({
-      // Right now the backend will rewrite this payer Key to the server's address
-      payerKey: new PublicKey(this.address),
-      recentBlockhash: blockhash,
+    return createSolanaSponsoredTransaction(
       instructions,
-    }).compileToV0Message();
-    const versionedTransaction = new VersionedTransaction(message);
-    const serializedTransaction = Buffer.from(
-      versionedTransaction.serialize(),
-    ).toString("base64");
-    const body = JSON.stringify({
-      id: crypto?.randomUUID() ?? Math.floor(Math.random() * 1000000),
-      jsonrpc: "2.0",
-      method: "alchemy_requestFeePayer",
-      params: [
-        {
-          policyId,
-          serializedTransaction,
-        },
-      ],
-    });
-    const options = {
-      method: "POST",
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-      },
-      body,
-    };
-
-    const response = await fetch(
-      // TODO: Use the connection??
-      connection.rpcEndpoint,
-      options,
-    );
-    const jsonResponse = await response.json();
-    if (!jsonResponse?.result?.serializedTransaction)
-      throw new Error(
-        `Response doesn't include the serializedTransaction ${JSON.stringify(
-          jsonResponse,
-        )}`,
-      );
-    return VersionedTransaction.deserialize(
-      decodeBase64(jsonResponse.result.serializedTransaction),
+      connection,
+      policyId,
+      this.address,
     );
   }
 
@@ -225,6 +184,3 @@ export class SolanaSigner {
     return toHex(messageToSign);
   }
 }
-function decodeBase64(serializedTransaction: string): Uint8Array {
-  return Buffer.from(serializedTransaction, "base64");
-}

package/src/types.ts

@@ -24,6 +24,7 @@ export enum AlchemySignerStatus {
   AUTHENTICATING_EMAIL = "AUTHENTICATING_EMAIL",
   AUTHENTICATING_OAUTH = "AUTHENTICATING_OAUTH",
   AWAITING_EMAIL_AUTH = "AWAITING_EMAIL_AUTH",
+  AWAITING_SMS_AUTH = "AWAITING_SMS_AUTH",
   AWAITING_OTP_AUTH = "AWAITING_OTP_AUTH",
   AWAITING_MFA_AUTH = "AWAITING_MFA_AUTH",
 }

package/src/utils/solana.ts

@@ -0,0 +1,100 @@
+import type { TransactionInstruction } from "@solana/web3.js";
+import {
+  Connection,
+  PublicKey,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+
+/**
+ * This function wraps instructions in a sponsored transaction using Alchemy's fee payer service
+ *
+ * @param {TransactionInstruction[]} instructions - The instructions to add sponsorship to
+ * @param {Connection} connection - The connection to use
+ * @param {string} policyId - The policy id to use
+ * @param {string} address - The address to use
+ * @returns {Promise<VersionedTransaction>} - The sponsored transaction
+ */
+export async function createSolanaSponsoredTransaction(
+  instructions: TransactionInstruction[],
+  connection: Connection,
+  policyId: string,
+  address: string,
+): Promise<VersionedTransaction> {
+  const { blockhash } = await connection.getLatestBlockhash({
+    commitment: "finalized",
+  });
+  const message = new TransactionMessage({
+    // Right now the backend will rewrite this payer Key to the server's address
+    payerKey: new PublicKey(address),
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+  const versionedTransaction = new VersionedTransaction(message);
+  const serializedTransaction = Buffer.from(
+    versionedTransaction.serialize(),
+  ).toString("base64");
+  const body = JSON.stringify({
+    id: crypto?.randomUUID() ?? Math.floor(Math.random() * 1000000),
+    jsonrpc: "2.0",
+    method: "alchemy_requestFeePayer",
+    params: [
+      {
+        policyId,
+        serializedTransaction,
+      },
+    ],
+  });
+  const options = {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json",
+    },
+    body,
+  };
+
+  const response = await fetch(
+    // TODO: Use the connection??
+    connection.rpcEndpoint,
+    options,
+  );
+  const jsonResponse = await response.json();
+  if (!jsonResponse?.result?.serializedTransaction)
+    throw new Error(
+      `Response doesn't include the serializedTransaction ${JSON.stringify(
+        jsonResponse,
+      )}`,
+    );
+  return VersionedTransaction.deserialize(
+    decodeBase64(jsonResponse.result.serializedTransaction),
+  );
+}
+
+/**
+ * Creates a regular (non-sponsored) Solana transaction from instructions
+ *
+ * @param {TransactionInstruction[]} instructions - The instructions to create transaction from
+ * @param {Connection} connection - The connection to use
+ * @param {string} address - The payer address
+ * @returns {Promise<VersionedTransaction>} - The transaction
+ */
+export async function createSolanaTransaction(
+  instructions: TransactionInstruction[],
+  connection: Connection,
+  address: string,
+): Promise<VersionedTransaction> {
+  const { blockhash } = await connection.getLatestBlockhash({
+    commitment: "finalized",
+  });
+  const message = new TransactionMessage({
+    payerKey: new PublicKey(address),
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message();
+  return new VersionedTransaction(message);
+}
+
+function decodeBase64(serializedTransaction: string): Uint8Array {
+  return Buffer.from(serializedTransaction, "base64");
+}

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "4.52.4";
+export const VERSION = "4.53.1-alpha.0";