jazz-tools 0.10.12 → 0.10.14

package/dist/index.js

@@ -35,7 +35,7 @@ import {
   parseInviteLink,
   randomSessionProvider,
   subscribeToCoValue
-} from "./chunk-RL7HVQ5Q.js";
+} from "./chunk-5YDDEUNX.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-5YDDEUNX.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.14",
   "dependencies": {
     "@scure/bip39": "^1.3.0",
     "cojson": "0.10.8"

package/src/auth/AuthSecretStorage.ts

@@ -16,7 +16,6 @@ export type AuthSetPayload = {
 export class AuthSecretStorage {
   private listeners: Set<(isAuthenticated: boolean) => void>;
   public isAuthenticated: boolean;
-  notify = false;
 
   constructor() {
     this.listeners = new Set();
@@ -97,7 +96,7 @@ export class AuthSecretStorage {
     };
   }
 
-  async set(payload: AuthSetPayload) {
+  async setWithoutNotify(payload: AuthSetPayload) {
     const kvStore = KvStoreContext.getInstance().getStorage();
     await kvStore.set(
       STORAGE_KEY,
@@ -110,10 +109,11 @@ export class AuthSecretStorage {
         provider: payload.provider,
       }),
     );
+  }
 
-    if (this.notify) {
-      this.emitUpdate(payload);
-    }
+  async set(payload: AuthSetPayload) {
+    this.setWithoutNotify(payload);
+    this.emitUpdate(payload);
   }
 
   getIsAuthenticated(data: AuthCredentials | null): boolean {
@@ -139,12 +139,13 @@ export class AuthSecretStorage {
     }
   }
 
-  async clear() {
+  async clearWithoutNotify() {
     const kvStore = KvStoreContext.getInstance().getStorage();
     await kvStore.delete(STORAGE_KEY);
+  }
 
-    if (this.notify) {
-      this.emitUpdate(null);
-    }
+  async clear() {
+    await this.clearWithoutNotify();
+    this.emitUpdate(null);
   }
 }

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

@@ -43,10 +43,6 @@ export class JazzContextManager<
   protected context: PlatformSpecificContext<Acc> | undefined;
   protected props: P | undefined;
   protected authSecretStorage = new AuthSecretStorage();
-  protected authSecretStorageWithNotify = Object.assign(
-    Object.create(this.authSecretStorage),
-    { notify: true },
-  );
   protected authenticating = false;
 
   constructor() {
@@ -80,6 +76,7 @@ export class JazzContextManager<
       ...context,
       node: context.node,
       authenticate: this.authenticate,
+      register: this.register,
       logOut: this.logOut,
     };
 
@@ -102,9 +99,7 @@ export class JazzContextManager<
   }
 
   getAuthSecretStorage() {
-    // External updates of the auth secret storage are notified by default (e.g. when registering a new Auth provider)
-    // We skip internal notify to ensure that the isAuthenticated changes are notified along with the context updates
-    return this.authSecretStorageWithNotify;
+    return this.authSecretStorage;
   }
 
   logOut = async () => {
@@ -143,14 +138,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 +218,7 @@ export class JazzContextManager<
     }
 
     prevContext?.done();
-  };
+  }
 
   listeners = new Set<() => void>();
   subscribe = (callback: () => void) => {

package/src/implementation/createContext.ts

@@ -219,7 +219,7 @@ export async function createJazzContext<Acc extends Account>(options: {
       AccountSchema: options.AccountSchema,
       sessionProvider: options.sessionProvider,
       onLogOut: () => {
-        authSecretStorage.clear();
+        authSecretStorage.clearWithoutNotify();
       },
     });
   } else {
@@ -240,12 +240,12 @@ export async function createJazzContext<Acc extends Account>(options: {
       crypto,
       AccountSchema: options.AccountSchema,
       onLogOut: async () => {
-        await authSecretStorage.clear();
+        await authSecretStorage.clearWithoutNotify();
       },
     });
 
     if (!options.newAccountProps) {
-      await authSecretStorage.set({
+      await authSecretStorage.setWithoutNotify({
         accountID: context.account.id,
         secretSeed,
         accountSecret: context.node.account.agentSecret,

package/src/tests/AuthSecretStorage.test.ts

@@ -257,11 +257,10 @@ describe("AuthSecretStorage", () => {
     });
   });
 
-  describe("notify=true", () => {
+  describe("notify", () => {
     beforeEach(() => {
       kvStore.clearAll();
       authSecretStorage = new AuthSecretStorage();
-      authSecretStorage.notify = true;
     });
 
     describe("set", () => {
@@ -337,7 +336,7 @@ describe("AuthSecretStorage", () => {
     });
   });
 
-  describe("notify=false", () => {
+  describe("without notify", () => {
     beforeEach(() => {
       kvStore.clearAll();
       authSecretStorage = new AuthSecretStorage();
@@ -348,7 +347,7 @@ describe("AuthSecretStorage", () => {
         const handler = vi.fn();
         authSecretStorage.onUpdate(handler);
 
-        await authSecretStorage.set({
+        await authSecretStorage.setWithoutNotify({
           accountID: "test123" as ID<Account>,
           accountSecret:
             "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
@@ -365,7 +364,7 @@ describe("AuthSecretStorage", () => {
       });
 
       it("should return false for anonymous credentials", async () => {
-        await authSecretStorage.set({
+        await authSecretStorage.setWithoutNotify({
           accountID: "test123" as ID<Account>,
           accountSecret:
             "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
@@ -376,7 +375,7 @@ describe("AuthSecretStorage", () => {
       });
 
       it("should return true for non-anonymous credentials", async () => {
-        await authSecretStorage.set({
+        await authSecretStorage.setWithoutNotify({
           accountID: "test123" as ID<Account>,
           accountSecret:
             "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
@@ -395,7 +394,7 @@ describe("AuthSecretStorage", () => {
       });
 
       it("should return true when the provider is missing", async () => {
-        await authSecretStorage.set({
+        await authSecretStorage.setWithoutNotify({
           accountID: "test123" as ID<Account>,
           accountSecret:
             "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
@@ -414,7 +413,7 @@ describe("AuthSecretStorage", () => {
 
     describe("clear", () => {
       it("should not emit update event when clearing", async () => {
-        await authSecretStorage.set({
+        await authSecretStorage.setWithoutNotify({
           accountID: "test123" as ID<Account>,
           accountSecret:
             "secret123" as `sealerSecret_z${string}/signerSecret_z${string}`,
@@ -424,7 +423,7 @@ describe("AuthSecretStorage", () => {
         const handler = vi.fn();
         authSecretStorage.onUpdate(handler);
 
-        await authSecretStorage.clear();
+        await authSecretStorage.clearWithoutNotify();
 
         expect(handler).not.toHaveBeenCalled();
       });

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

@@ -1,7 +1,7 @@
 // @vitest-environment happy-dom
 
-import { mnemonicToEntropy } from "@scure/bip39";
 import { AgentSecret } from "cojson";
+import { PureJSCrypto } from "cojson/crypto/PureJSCrypto";
 import {
   Account,
   AuthSecretStorage,
@@ -9,31 +9,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 +51,7 @@ describe("PassphraseAuth", () => {
     passphraseAuth = new PassphraseAuth(
       crypto,
       mockAuthenticate,
+      mockRegister,
       authSecretStorage,
       testWordlist,
     );
@@ -121,6 +132,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 +194,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;

package/tsconfig.json

@@ -12,5 +12,5 @@
     "esModuleInterop": true
   },
   "include": ["./src/**/*.ts"],
-  "exclude": ["./node_modules", "./src/tests"]
+  "exclude": ["./node_modules"]
 }