Testing every permutation of methods and sequences

typescript/packages/jumble/src/contexts/AuthenticationContext.tsx

@@ -10,9 +10,9 @@ interface AuthenticationContextType {
   // The authenticated user/persona.
   user: Identity | void;
   // Call PassKey registration.
-  passkeyRegister: (name: string, displayName: string) => Promise<PublicKeyCredential>;
+  passkeyRegister: (name: string, displayName: string) => Promise<PassKey>;
   // Authenticate the user via passkey.
-  passkeyAuthenticate: (descriptor?: PublicKeyCredentialDescriptor) => Promise<void>;
+  passkeyAuthenticate: (descriptor?: PublicKeyCredentialDescriptor) => Promise<PassKey>;
   // Generate a passphrase for a new user
   passphraseRegister: () => Promise<string>;
   // Authenticate via passphrase.
@@ -89,13 +89,14 @@ export const AuthenticationProvider: React.FC<{ children: React.ReactNode }> = (
   const passkeyAuthenticate = useCallback(
     async (key?: PublicKeyCredentialDescriptor) => {
       if (!keyStore) {
-        return;
+        throw new Error("Key store not initialized");
       }
       // Pass the keyName to PassKey.get() if provided
       const passkey = await PassKey.get({ allowCredentials: key ? [key] : [] });
       const root = await passkey.createRootKey();
       await keyStore.set(ROOT_KEY, root);
       setRoot(root);
+      return passkey;
     },
     [keyStore],
   );

typescript/packages/jumble/src/utils/credentials.ts

@@ -0,0 +1,46 @@
+export interface StoredCredential {
+  id: string;
+  type: "public-key" | "passphrase";
+  method: "passkey" | "passphrase";
+}
+
+export function getStoredCredential(): StoredCredential | null {
+  const stored = localStorage.getItem("storedCredential");
+  return stored ? JSON.parse(stored) : null;
+}
+
+export function saveCredential(credential: StoredCredential): void {
+  localStorage.setItem("storedCredential", JSON.stringify(credential));
+}
+
+export function clearStoredCredential(): void {
+  localStorage.removeItem("storedCredential");
+}
+
+export function createPasskeyCredential(id: string): StoredCredential {
+  return {
+    id,
+    type: "public-key",
+    method: "passkey",
+  };
+}
+
+export function createPassphraseCredential(): StoredCredential {
+  return {
+    id: crypto.randomUUID(),
+    type: "passphrase",
+    method: "passphrase",
+  };
+}
+
+export function getPublicKeyCredentialDescriptor(
+  storedCredential: StoredCredential | null,
+): PublicKeyCredentialDescriptor | undefined {
+  if (storedCredential?.type === "public-key") {
+    return {
+      id: Uint8Array.from(atob(storedCredential.id), (c) => c.charCodeAt(0)),
+      type: "public-key" as PublicKeyCredentialType,
+    };
+  }
+  return undefined;
+}