jazz-tools 0.10.12 → 0.10.13

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-RL7HVQ5Q.js";
+} from "./chunk-GSIV52ZH.js";
 
 // src/index.ts
 import { MAX_RECOMMENDED_TX_SIZE, cojsonInternals } from "cojson";

package/dist/testing.js

@@ -5,7 +5,7 @@ import {
   createAnonymousJazzContext,
   createJazzContext,
   randomSessionProvider
-} from "./chunk-RL7HVQ5Q.js";
+} from "./chunk-GSIV52ZH.js";
 
 // src/testing.ts
 import { LocalNode } from "cojson";

package/package.json

@@ -17,7 +17,7 @@
   },
   "type": "module",
   "license": "MIT",
-  "version": "0.10.12",
+  "version": "0.10.13",
   "dependencies": {
     "@scure/bip39": "^1.3.0",
     "cojson": "0.10.8"

package/src/auth/PassphraseAuth.ts

@@ -3,7 +3,10 @@ import { entropyToMnemonic } from "@scure/bip39";
 import { CryptoProvider, cojsonInternals } from "cojson";
 import { Account } from "../coValues/account.js";
 import type { ID } from "../internal.js";
-import type { AuthenticateAccountFunction } from "../types.js";
+import type {
+  AuthenticateAccountFunction,
+  RegisterAccountFunction,
+} from "../types.js";
 import { AuthSecretStorage } from "./AuthSecretStorage.js";
 
 /**
@@ -23,6 +26,7 @@ export class PassphraseAuth {
   constructor(
     private crypto: CryptoProvider,
     private authenticate: AuthenticateAccountFunction,
+    private register: RegisterAccountFunction,
     private authSecretStorage: AuthSecretStorage,
     public wordlist: string[],
   ) {}
@@ -61,7 +65,7 @@ export class PassphraseAuth {
     this.notify();
   };
 
-  signUp = async () => {
+  signUp = async (name?: string) => {
     const credentials = await this.authSecretStorage.get();
 
     if (!credentials || !credentials.secretSeed) {
@@ -77,9 +81,32 @@ export class PassphraseAuth {
       provider: "passphrase",
     });
 
+    if (name?.trim()) {
+      const currentAccount = await Account.getMe().ensureLoaded({
+        profile: {},
+      });
+
+      currentAccount.profile.name = name;
+    }
+
     return passphrase;
   };
 
+  registerNewAccount = async (passphrase: string, name: string) => {
+    const secretSeed = bip39.mnemonicToEntropy(passphrase, this.wordlist);
+    const accountSecret = this.crypto.agentSecretFromSecretSeed(secretSeed);
+    const accountID = await this.register(accountSecret, { name });
+
+    await this.authSecretStorage.set({
+      accountID,
+      secretSeed,
+      accountSecret,
+      provider: "passphrase",
+    });
+
+    return accountID;
+  };
+
   getCurrentAccountPassphrase = async () => {
     const credentials = await this.authSecretStorage.get();
 
@@ -90,6 +117,10 @@ export class PassphraseAuth {
     return entropyToMnemonic(credentials.secretSeed, this.wordlist);
   };
 
+  generateRandomPassphrase = () => {
+    return entropyToMnemonic(this.crypto.newRandomSecretSeed(), this.wordlist);
+  };
+
   loadCurrentAccountPassphrase = async () => {
     const passphrase = await this.getCurrentAccountPassphrase();
     this.passphrase = passphrase;

package/src/implementation/ContextManager.ts

@@ -80,6 +80,7 @@ export class JazzContextManager<
       ...context,
       node: context.node,
       authenticate: this.authenticate,
+      register: this.register,
       logOut: this.logOut,
     };
 
@@ -143,14 +144,59 @@ export class JazzContextManager<
       this.authenticating = false;
     });
 
+    if (wasAnonymous) {
+      await this.handleAnonymousAccountMigration(prevContext);
+    }
+  };
+
+  register = async (
+    accountSecret: AgentSecret,
+    creationProps: { name: string },
+  ) => {
+    if (!this.props) {
+      throw new Error("Props required");
+    }
+
+    const prevContext = this.context;
+    const prevCredentials = await this.authSecretStorage.get();
+    const wasAnonymous =
+      this.authSecretStorage.getIsAuthenticated(prevCredentials) === false;
+
+    this.authenticating = true;
+    await this.createContext(this.props, {
+      newAccountProps: {
+        secret: accountSecret,
+        creationProps,
+      },
+    }).finally(() => {
+      this.authenticating = false;
+    });
+
+    if (wasAnonymous) {
+      await this.handleAnonymousAccountMigration(prevContext);
+    }
+
+    if (this.context && "me" in this.context) {
+      return this.context.me.id;
+    }
+
+    throw new Error("The registration hasn't created a new account");
+  };
+
+  private async handleAnonymousAccountMigration(
+    prevContext: PlatformSpecificContext<Acc> | undefined,
+  ) {
+    if (!this.props) {
+      throw new Error("Props required");
+    }
+
     const currentContext = this.context;
 
     if (
       prevContext &&
       currentContext &&
       "me" in prevContext &&
-      "me" in currentContext &&
-      wasAnonymous
+      "me" in currentContext
     ) {
       // Using a direct connection to make coValue transfer almost synchronous
       const [prevAccountAsPeer, currentAccountAsPeer] =
@@ -178,7 +224,7 @@ export class JazzContextManager<
     }
 
     prevContext?.done();
-  };
+  }
 
   listeners = new Set<() => void>();
   subscribe = (callback: () => void) => {

package/src/tests/ContextManager.test.ts

@@ -338,4 +338,53 @@ describe("ContextManager", () => {
 
     expect(me.root.transferredRoot?.value).toBe("Hello");
   });
+
+  test("handles registration of new account", async () => {
+    const onAnonymousAccountDiscarded = vi.fn();
+    await manager.createContext({ onAnonymousAccountDiscarded });
+
+    const secret = Crypto.newRandomAgentSecret();
+    const accountId = await manager.register(secret, { name: "Test User" });
+
+    expect(accountId).toBeDefined();
+    const context = getCurrentValue();
+    expect(context.me.profile?.name).toBe("Test User");
+    expect(context.me.id).toBe(accountId);
+  });
+
+  test("calls onAnonymousAccountDiscarded when registering from anonymous user", async () => {
+    const onAnonymousAccountDiscarded = vi.fn();
+    await manager.createContext({ onAnonymousAccountDiscarded });
+    const anonymousAccount = getCurrentValue().me;
+
+    const secret = Crypto.newRandomAgentSecret();
+    await manager.register(secret, { name: "Test User" });
+
+    expect(onAnonymousAccountDiscarded).toHaveBeenCalledWith(anonymousAccount);
+  });
+
+  test("does not call onAnonymousAccountDiscarded when registering from authenticated user", async () => {
+    const onAnonymousAccountDiscarded = vi.fn();
+    const account = await createJazzTestAccount();
+
+    await manager.getAuthSecretStorage().set({
+      accountID: account.id,
+      accountSecret: account._raw.core.node.account.agentSecret,
+      provider: "test",
+    });
+
+    await manager.createContext({ onAnonymousAccountDiscarded });
+
+    const secret = Crypto.newRandomAgentSecret();
+    await manager.register(secret, { name: "New User" });
+
+    expect(onAnonymousAccountDiscarded).not.toHaveBeenCalled();
+  });
+
+  test("throws error when registering without props", async () => {
+    const secret = Crypto.newRandomAgentSecret();
+    await expect(
+      manager.register(secret, { name: "Test User" }),
+    ).rejects.toThrow("Props required");
+  });
 });

package/src/tests/PassphraseAuth.test.ts

@@ -2,6 +2,7 @@
 
 import { mnemonicToEntropy } from "@scure/bip39";
 import { AgentSecret } from "cojson";
+import { PureJSCrypto } from "cojson/src/crypto/PureJSCrypto";
 import {
   Account,
   AuthSecretStorage,
@@ -9,31 +10,41 @@ import {
   InMemoryKVStore,
   KvStoreContext,
 } from "jazz-tools";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { assert, beforeEach, describe, expect, it, vi } from "vitest";
 import { PassphraseAuth } from "../auth/PassphraseAuth";
-import { createJazzTestAccount } from "../testing";
-import { TestJSCrypto } from "../testing";
+import {
+  TestJazzContextManager,
+  createJazzTestAccount,
+  setupJazzTestSync,
+} from "../testing";
 import { testWordlist } from "./fixtures";
 
 // Initialize KV store for tests
 KvStoreContext.getInstance().initialize(new InMemoryKVStore());
 
+beforeEach(async () => {
+  await setupJazzTestSync();
+});
+
 describe("PassphraseAuth", () => {
-  let crypto: TestJSCrypto;
+  let crypto: PureJSCrypto;
   let mockAuthenticate: any;
+  let mockRegister: any;
   let authSecretStorage: AuthSecretStorage;
   let passphraseAuth: PassphraseAuth;
+  let account: Account;
 
   beforeEach(async () => {
     // Reset storage
     KvStoreContext.getInstance().getStorage().clearAll();
 
     // Set up crypto and mocks
-    crypto = await TestJSCrypto.create();
+    crypto = await PureJSCrypto.create();
     mockAuthenticate = vi.fn();
+    mockRegister = vi.fn();
     authSecretStorage = new AuthSecretStorage();
 
-    await createJazzTestAccount({
+    account = await createJazzTestAccount({
       isCurrentActiveAccount: true,
     });
 
@@ -41,6 +52,7 @@ describe("PassphraseAuth", () => {
     passphraseAuth = new PassphraseAuth(
       crypto,
       mockAuthenticate,
+      mockRegister,
       authSecretStorage,
       testWordlist,
     );
@@ -121,6 +133,39 @@ describe("PassphraseAuth", () => {
         "No credentials found",
       );
     });
+
+    it("should set account name when provided during signup", async () => {
+      const storageData = {
+        accountID: "test-account-id" as ID<Account>,
+        accountSecret: "test-secret" as AgentSecret,
+        secretSeed: new Uint8Array([
+          173, 58, 235, 40, 67, 188, 236, 11, 107, 237, 97, 23, 182, 49, 188,
+          63, 237, 52, 27, 84, 142, 66, 244, 149, 243, 114, 203, 164, 115, 239,
+          175, 194,
+        ]),
+        provider: "anonymous",
+      };
+
+      await authSecretStorage.set(storageData);
+
+      const testName = "Test User";
+      await passphraseAuth.signUp(testName);
+
+      // Verify the account name was set
+      const { profile } = await account.ensureLoaded({
+        profile: {},
+      });
+      expect(profile.name).toBe(testName);
+
+      // Verify storage was updated correctly
+      const storedData = await authSecretStorage.get();
+      expect(storedData).toEqual({
+        accountID: storageData.accountID,
+        accountSecret: storageData.accountSecret,
+        secretSeed: storageData.secretSeed,
+        provider: "passphrase",
+      });
+    });
   });
 
   describe("getCurrentAccountPassphrase", () => {
@@ -150,3 +195,153 @@ describe("PassphraseAuth", () => {
     });
   });
 });
+
+// Initialize KV store for tests
+KvStoreContext.getInstance().initialize(new InMemoryKVStore());
+
+describe("PassphraseAuth with TestJazzContextManager", () => {
+  let crypto: PureJSCrypto;
+  let contextManager: TestJazzContextManager<any>;
+  let authSecretStorage: AuthSecretStorage;
+  let passphraseAuth: PassphraseAuth;
+
+  beforeEach(async () => {
+    // Reset storage
+    KvStoreContext.getInstance().getStorage().clearAll();
+
+    const account = await createJazzTestAccount({
+      isCurrentActiveAccount: true,
+    });
+
+    // Set up crypto and context manager
+    crypto = await PureJSCrypto.create();
+    contextManager = TestJazzContextManager.fromAccountOrGuest(account);
+    authSecretStorage = contextManager.getAuthSecretStorage();
+
+    // Create initial context
+    await contextManager.createContext({});
+
+    // Create PassphraseAuth instance
+    passphraseAuth = new PassphraseAuth(
+      crypto,
+      contextManager.authenticate,
+      contextManager.register,
+      authSecretStorage,
+      testWordlist,
+    );
+  });
+
+  describe("logIn", () => {
+    it("should successfully log in with valid passphrase", async () => {
+      // First sign up to create initial credentials
+      const passphrase = await passphraseAuth.signUp();
+
+      // Log out
+      await contextManager.logOut();
+
+      // Log back in with passphrase
+      await passphraseAuth.logIn(passphrase);
+
+      // Verify we're logged in
+      const context = contextManager.getCurrentValue();
+
+      assert(context && "me" in context);
+
+      // Verify storage was updated
+      const storedData = await authSecretStorage.get();
+      expect(storedData?.provider).toBe("passphrase");
+    });
+
+    it("should throw error with invalid passphrase", async () => {
+      await expect(passphraseAuth.logIn("invalid words here")).rejects.toThrow(
+        "Invalid passphrase",
+      );
+    });
+  });
+
+  describe("signUp", () => {
+    it("should successfully sign up new user", async () => {
+      expect(authSecretStorage.isAuthenticated).toBe(false);
+
+      const passphrase = await passphraseAuth.signUp();
+
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+
+      // Verify passphrase format
+      expect(passphrase.split(" ").length).toBeGreaterThan(0);
+
+      // Verify storage was updated
+      const storedData = await authSecretStorage.get();
+      expect(storedData?.provider).toBe("passphrase");
+
+      // Verify we can log in with the passphrase
+      await contextManager.logOut();
+      await passphraseAuth.logIn(passphrase);
+      const context = contextManager.getCurrentValue();
+      assert(context && "me" in context);
+      expect(context.me).toBeDefined();
+    });
+
+    it("should throw error when no credentials found", async () => {
+      await authSecretStorage.clear();
+      await expect(passphraseAuth.signUp()).rejects.toThrow(
+        "No credentials found",
+      );
+    });
+  });
+
+  describe("registerNewAccount", () => {
+    it("should successfully register new account with passphrase", async () => {
+      expect(authSecretStorage.isAuthenticated).toBe(false);
+
+      const passphrase = passphraseAuth.generateRandomPassphrase();
+      const accountId = await passphraseAuth.registerNewAccount(
+        passphrase,
+        "Test User",
+      );
+
+      // Verify account was created
+      expect(accountId).toBeDefined();
+
+      // Verify we can log in with the passphrase
+      await contextManager.logOut();
+      await passphraseAuth.logIn(passphrase);
+
+      const context = contextManager.getCurrentValue();
+
+      assert(context && "me" in context);
+      expect(context.me.id).toBe(accountId);
+      expect(context.me.profile?.name).toBe("Test User");
+
+      expect(authSecretStorage.isAuthenticated).toBe(true);
+
+      const credentials = await authSecretStorage.get();
+      assert(credentials);
+      expect(credentials.accountID).toBe(accountId);
+      expect(credentials.provider).toBe("passphrase");
+    });
+
+    it("should throw error with invalid passphrase during registration", async () => {
+      await expect(
+        passphraseAuth.registerNewAccount("invalid words", "Test User"),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("getCurrentAccountPassphrase", () => {
+    it("should return current user passphrase when credentials exist", async () => {
+      const originalPassphrase = await passphraseAuth.signUp();
+      const retrievedPassphrase =
+        await passphraseAuth.getCurrentAccountPassphrase();
+
+      expect(retrievedPassphrase).toBe(originalPassphrase);
+    });
+
+    it("should throw error when no credentials found", async () => {
+      await authSecretStorage.clear();
+      await expect(
+        passphraseAuth.getCurrentAccountPassphrase(),
+      ).rejects.toThrow("No credentials found");
+    });
+  });
+});

package/src/types.ts

@@ -12,6 +12,7 @@ export type AuthCredentials = {
 export type AuthenticateAccountFunction = (
   credentials: AuthCredentials,
 ) => Promise<void>;
+
 export type RegisterAccountFunction = (
   accountSecret: AgentSecret,
   creationProps: { name: string },
@@ -22,6 +23,7 @@ export type JazzAuthContext<Acc extends Account> = {
   me: Acc;
   node: LocalNode;
   authenticate: AuthenticateAccountFunction;
+  register: RegisterAccountFunction;
   logOut: () => Promise<void>;
   done: () => void;
   isAuthenticated?: boolean;
@@ -31,6 +33,7 @@ export type JazzGuestContext = {
   guest: AnonymousJazzAgent;
   node: LocalNode;
   authenticate: AuthenticateAccountFunction;
+  register: RegisterAccountFunction;
   logOut: () => void;
   done: () => void;
   isAuthenticated?: boolean;