@account-kit/react-native-signer 4.9.0 → 4.11.0

package/src/client.ts

@@ -1,8 +1,11 @@
+import "./utils/buffer-polyfill.js";
+import "./utils/mmkv-localstorage-polyfill.js";
+
 /* eslint-disable import/extensions */
-import "./utils/mmkv-localstorage-polyfill";
 import { type ConnectionConfig } from "@aa-sdk/core";
 import {
   BaseSignerClient,
+  OauthFailedError,
   type AlchemySignerClientEvents,
   type AuthenticatingEventMetadata,
   type CreateAccountParams,
@@ -14,12 +17,19 @@ import {
   type SignupResponse,
   type User,
 } from "@account-kit/signer";
-import NativeTEKStamper from "./NativeTEKStamper";
+import { InAppBrowser } from "react-native-inappbrowser-reborn";
 import { z } from "zod";
+import { InAppBrowserUnavailableError } from "./errors";
+import NativeTEKStamper from "./NativeTEKStamper.js";
+import { parseSearchParams } from "./utils/parseUrlParams";
 
 export const RNSignerClientParamsSchema = z.object({
   connection: z.custom<ConnectionConfig>(),
   rootOrgId: z.string().optional(),
+  oauthCallbackUrl: z
+    .string()
+    .optional()
+    .default("https://signer.alchemy.com/callback"),
 });
 
 export type RNSignerClientParams = z.input<typeof RNSignerClientParamsSchema>;
@@ -27,14 +37,24 @@ export type RNSignerClientParams = z.input<typeof RNSignerClientParamsSchema>;
 // TODO: need to emit events
 export class RNSignerClient extends BaseSignerClient<undefined> {
   private stamper = NativeTEKStamper;
+  oauthCallbackUrl: string;
+  private validAuthenticatingTypes: AuthenticatingEventMetadata["type"][] = [
+    "email",
+    "otp",
+    "oauth",
+  ];
+
   constructor(params: RNSignerClientParams) {
-    const { connection, rootOrgId } = RNSignerClientParamsSchema.parse(params);
+    const { connection, rootOrgId, oauthCallbackUrl } =
+      RNSignerClientParamsSchema.parse(params);
 
     super({
       stamper: NativeTEKStamper,
       rootOrgId: rootOrgId ?? "24c1acf5-810f-41e0-a503-d5d13fa8e830",
       connection,
     });
+
+    this.oauthCallbackUrl = oauthCallbackUrl;
   }
 
   override async submitOtpCode(
@@ -95,14 +115,14 @@ export class RNSignerClient extends BaseSignerClient<undefined> {
     authenticatingType: AuthenticatingEventMetadata["type"];
     idToken?: string;
   }): Promise<User> {
-    if (
-      params.authenticatingType !== "email" &&
-      params.authenticatingType !== "otp"
-    ) {
+    if (!this.validAuthenticatingTypes.includes(params.authenticatingType)) {
       throw new Error("Unsupported authenticating type");
     }
 
-    this.eventEmitter.emit("authenticating", { type: "email" });
+    this.eventEmitter.emit("authenticating", {
+      type: params.authenticatingType,
+    });
+
     await this.stamper.init();
 
     const result = await this.stamper.injectCredentialBundle(params.bundle);
@@ -116,15 +136,67 @@ export class RNSignerClient extends BaseSignerClient<undefined> {
     this.eventEmitter.emit(params.connectedEventName, user, params.bundle);
     return user;
   }
-  override oauthWithRedirect(
-    _args: Extract<OauthParams, { mode: "redirect" }>
-  ): Promise<never> {
-    throw new Error("Method not implemented.");
-  }
+  override oauthWithRedirect = async (
+    args: Extract<OauthParams, { mode: "redirect" }>
+  ): Promise<User> => {
+    // Ensure the In-App Browser required for authentication is available
+    if (!(await InAppBrowser.isAvailable())) {
+      throw new InAppBrowserUnavailableError();
+    }
+
+    this.eventEmitter.emit("authenticating", { type: "oauth" });
+
+    const oauthParams = args;
+    const turnkeyPublicKey = await this.stamper.init();
+    const oauthCallbackUrl = this.oauthCallbackUrl;
+    const oauthConfig = await this.getOauthConfig();
+    const providerUrl = await this.getOauthProviderUrl({
+      oauthParams,
+      turnkeyPublicKey,
+      oauthCallbackUrl,
+      oauthConfig,
+      usesRelativeUrl: false,
+    });
+    const redirectUrl = args.redirectUrl;
+    const res = await InAppBrowser.openAuth(providerUrl, redirectUrl);
+
+    if (res.type !== "success" || !res.url) {
+      throw new OauthFailedError("An error occured completing your request");
+    }
+
+    const authResult = parseSearchParams(res.url);
+    const bundle = authResult["alchemy-bundle"] ?? "";
+    const orgId = authResult["alchemy-org-id"] ?? "";
+    const idToken = authResult["alchemy-id-token"] ?? "";
+    const isSignup = authResult["alchemy-is-signup"];
+    const error = authResult["alchemy-error"];
+
+    if (bundle && orgId && idToken) {
+      const user = await this.completeAuthWithBundle({
+        bundle,
+        orgId,
+        connectedEventName: "connectedOauth",
+        idToken,
+        authenticatingType: "oauth",
+      });
+
+      if (isSignup) {
+        this.eventEmitter.emit("newUserSignup");
+      }
+
+      return user;
+    }
+
+    // Throw the Alchemy error if available, otherwise throw a generic error.
+    throw new OauthFailedError(
+      error ?? "An error occured completing your request"
+    );
+  };
+
   override oauthWithPopup(
     _args: Extract<OauthParams, { mode: "popup" }>
   ): Promise<User> {
-    throw new Error("Method not implemented.");
+    throw new Error("Method not implemented");
   }
 
   override async disconnect(): Promise<void> {
@@ -138,13 +210,18 @@ export class RNSignerClient extends BaseSignerClient<undefined> {
   override lookupUserWithPasskey(_user?: User): Promise<User> {
     throw new Error("Method not implemented.");
   }
-  protected override getOauthConfig(): Promise<OauthConfig> {
-    throw new Error("Method not implemented.");
-  }
+
   protected override getWebAuthnAttestation(
     _options: CredentialCreationOptions,
     _userDetails?: { username: string }
   ): Promise<GetWebAuthnAttestationResult> {
     throw new Error("Method not implemented.");
   }
+
+  protected override getOauthConfig = async (): Promise<OauthConfig> => {
+    const publicKey = await this.stamper.init();
+
+    const nonce = this.getOauthNonce(publicKey);
+    return this.request("/v1/prepare-oauth", { nonce });
+  };
 }

package/src/errors.ts

@@ -0,0 +1,10 @@
+import { BaseError } from "@aa-sdk/core";
+
+export class InAppBrowserUnavailableError extends BaseError {
+  override name = "InAppBrowserUnavailableError";
+  constructor() {
+    super(
+      "In-App Browser is not available. Please authenticate with a different method."
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export type * from "./signer.js";
+export { RNAlchemySigner } from "./signer.js";

package/src/signer.ts

@@ -1,10 +1,9 @@
-import { z } from "zod";
 import {
   BaseAlchemySigner,
   SessionManagerParamsSchema,
 } from "@account-kit/signer";
-// eslint-disable-next-line import/extensions
-import { RNSignerClient, RNSignerClientParamsSchema } from "./client";
+import { z } from "zod";
+import { RNSignerClient, RNSignerClientParamsSchema } from "./client.js";
 
 const RNAlchemySignerParamsSchema = z
   .object({
@@ -19,8 +18,8 @@ const RNAlchemySignerParamsSchema = z
 
 export type RNAlchemySignerParams = z.input<typeof RNAlchemySignerParamsSchema>;
 
-class RNAlchemySignerSingleton extends BaseAlchemySigner<RNSignerClient> {
-  private static instance: BaseAlchemySigner<RNSignerClient>;
+export class RNAlchemySignerSingleton extends BaseAlchemySigner<RNSignerClient> {
+  private static instance: RNAlchemySignerSingleton;
 
   private constructor(params: RNAlchemySignerParams) {
     if (!!RNAlchemySignerSingleton.instance) {
@@ -37,6 +36,7 @@ class RNAlchemySignerSingleton extends BaseAlchemySigner<RNSignerClient> {
     } else {
       client = params_.client;
     }
+
     super({
       client,
       sessionConfig,
@@ -51,8 +51,33 @@ class RNAlchemySignerSingleton extends BaseAlchemySigner<RNSignerClient> {
   }
 }
 
+/**
+ * Factory function to create or retrieve a singleton instance of RNAlchemySigner.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RNAlchemySigner } from "@account-kit/react-native-signer";
+ *
+ * const signer = RNAlchemySigner({
+ *  client: {
+ *    connection: {
+ *      apiKey: "YOUR_API_KEY"
+ *    },
+ *  },
+ *  // optional config to override default session manager configs
+ *  sessionConfig: {
+ *    expirationTimeMs: 1000 * 60 * 60 // 60 minutes
+ *  }
+ * });
+ * ```
+ *
+ * @param {RNAlchemySignerParams} params The parameters required to configure the RNAlchemySigner instance.
+ * @returns {RNAlchemySignerSingleton} The singleton instance of RNAlchemySigner configured with the provided parameters.
+ */
 export function RNAlchemySigner(params: RNAlchemySignerParams) {
   const instance = RNAlchemySignerSingleton.getInstance(params);
 
   return instance;
 }
+
+export type RNAlchemySignerType = RNAlchemySignerSingleton;

package/src/utils/base64UrlEncode.ts

@@ -0,0 +1,11 @@
+import { Buffer } from "buffer";
+
+export const base64UrlEncode = (
+  challenge: ArrayBuffer | ArrayBufferLike
+): string => {
+  return Buffer.from(challenge)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+};

package/src/utils/buffer-polyfill.ts

@@ -0,0 +1,5 @@
+import { Buffer } from "buffer";
+
+if (!global.Buffer) {
+  global.Buffer = Buffer;
+}

package/src/utils/parseUrlParams.ts

@@ -0,0 +1,14 @@
+export const parseSearchParams = (url: string) => {
+  const regex = /[?&]([^=#]+)=([^&#]*)/g;
+
+  let params: Record<string, string> = {};
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(url))) {
+    if (match[1] !== undefined && match[2] !== undefined) {
+      params[match[1]] = match[2];
+    }
+  }
+
+  return params;
+};

package/src/index.tsx

@@ -1,2 +0,0 @@
-// eslint-disable-next-line import/extensions
-export { RNAlchemySigner } from "./signer";