@dxos/echo-db 2.33.1-dev.eb88db79 → 2.33.2-dev.0286e021

package/src/halo/halo-party.ts

@@ -2,10 +2,22 @@
 // Copyright 2020 DXOS.org
 //
 
+import assert from 'assert';
+
+import { Event, synchronized } from '@dxos/async';
 import { KeyHint } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-
-import { PartyInternal } from '../parties';
+import { timed } from '@dxos/debug';
+import { Timeframe } from '@dxos/echo-protocol';
+import { ModelFactory } from '@dxos/model-factory';
+import { NetworkManager } from '@dxos/network-manager';
+
+import { InvitationAuthenticator, InvitationDescriptor, InvitationFactory, InvitationOptions } from '../invitations';
+import { PARTY_ITEM_TYPE } from '../parties';
+import { PartyFeedProvider, PartyProtocolFactory, PartyCore, PartyOptions } from '../pipeline';
+import { createAuthenticator, createAuthPlugin, createCredentialsProvider, createHaloRecoveryPlugin } from '../protocol';
+import { CredentialsSigner } from '../protocol/credentials-signer';
+import { SnapshotStore } from '../snapshots';
 import { ContactManager } from './contact-manager';
 import { Preferences } from './preferences';
 
@@ -23,23 +35,56 @@ export interface JoinedParty {
 }
 
 /**
- * Wraps PartyInternal and provides all HALO-related functionality.
+ * Provides all HALO-related functionality.
  */
 export class HaloParty {
+  public readonly update = new Event<void>();
+
+  private readonly _partyCore: PartyCore;
+  private _invitationManager?: InvitationFactory;
+  private _protocol?: PartyProtocolFactory;
+
   private readonly _contactManager: ContactManager;
   private readonly _preferences: Preferences;
 
   constructor (
-    private readonly _party: PartyInternal,
-    private readonly _identityKey: PublicKey,
-    deviceKey: PublicKey
+    modelFactory: ModelFactory,
+    snapshotStore: SnapshotStore,
+    private readonly _feedProvider: PartyFeedProvider,
+    private readonly _credentialsSigner: CredentialsSigner,
+    private readonly _networkManager: NetworkManager,
+    private readonly _hints: KeyHint[] = [],
+    _initialTimeframe: Timeframe | undefined,
+    _options: PartyOptions
   ) {
-    this._contactManager = new ContactManager(this._party);
-    this._preferences = new Preferences(this._party, deviceKey);
+    this._partyCore = new PartyCore(
+      _credentialsSigner.getIdentityKey().publicKey,
+      _feedProvider,
+      modelFactory,
+      snapshotStore,
+      _credentialsSigner.getIdentityKey().publicKey,
+      _initialTimeframe,
+      _options
+    );
+
+    this._contactManager = new ContactManager(() => this.isOpen ? this.database : undefined);
+    this._preferences = new Preferences(
+      () => this.isOpen ? this.database : undefined,
+      _credentialsSigner.getDeviceKey().publicKey
+    );
+  }
+
+  /**
+   * Party key.
+   * Always equal to the identity key.
+   * @deprecated Should remove.
+   */
+  get key () {
+    return this._partyCore.key;
   }
 
   get isOpen () {
-    return this._party.isOpen;
+    return !!(this._partyCore.isOpen && this._protocol);
   }
 
   get contacts () {
@@ -52,7 +97,7 @@ export class HaloParty {
 
   // TODO(burdon): Remove.
   get database () {
-    return this._party.database;
+    return this._partyCore.database;
   }
 
   //
@@ -60,32 +105,103 @@ export class HaloParty {
   // (eg, identity, credentials, device management.)
   //
 
-  get invitationManager () {
-    return this._party.invitationManager;
-  }
-
   get identityInfo () {
-    return this._party.processor.infoMessages.get(this._identityKey.toHex());
+    return this._partyCore.processor.infoMessages.get(this._credentialsSigner.getIdentityKey().publicKey.toHex());
   }
 
   get identityGenesis () {
-    return this._party.processor.credentialMessages.get(this._identityKey.toHex());
+    return this._partyCore.processor.credentialMessages.get(this._credentialsSigner.getIdentityKey().publicKey.toHex());
   }
 
   get memberKeys () {
-    return this._party.processor.memberKeys;
+    return this._partyCore.processor.memberKeys;
   }
 
   get credentialMessages () {
-    return this._party.processor.credentialMessages;
+    return this._partyCore.processor.credentialMessages;
   }
 
   get feedKeys () {
-    return this._party.processor.feedKeys;
+    return this._partyCore.processor.feedKeys;
+  }
+
+  async getWriteFeedKey () {
+    const feed = await this._feedProvider.createOrOpenWritableFeed();
+    return feed.key;
   }
 
-  // TODO(burdon): Life-cycle: this must be in the same class/stack as open (currently IdentityManager).
+  get processor () {
+    return this._partyCore.processor;
+  }
+
+  /**
+   * Opens the pipeline and connects the streams.
+   */
+  @synchronized
+  @timed(5_000)
+  async open () {
+    if (this.isOpen) {
+      return this;
+    }
+
+    await this._partyCore.open(this._hints);
+
+    this._invitationManager = new InvitationFactory(
+      this._partyCore.processor,
+      this._credentialsSigner,
+      this._networkManager
+    );
+
+    //
+    // Network/swarm.
+    //
+
+    const writeFeed = await this._partyCore.getWriteFeed();
+    const peerId = this._credentialsSigner.getDeviceKey().publicKey;
+    this._protocol = new PartyProtocolFactory(
+      this._partyCore.key,
+      this._networkManager,
+      this._feedProvider,
+      peerId,
+      createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key),
+      this._partyCore.processor.getActiveFeedSet()
+    );
+
+    // Replication.
+    await this._protocol.start([
+      createAuthPlugin(createAuthenticator(this._partyCore.processor, this._credentialsSigner), peerId),
+      createHaloRecoveryPlugin(this._credentialsSigner.getIdentityKey().publicKey, this._invitationManager, peerId)
+    ]);
+
+    // Issue an 'update' whenever the properties change.
+    this.database.select({ type: PARTY_ITEM_TYPE }).exec().update.on(() => this.update.emit());
+
+    this.update.emit();
+    return this;
+  }
+
+  /**
+  * Closes the pipeline and streams.
+  */
+  @synchronized
   async close () {
-    await this._party.close();
+    if (!this.isOpen) {
+      return this;
+    }
+
+    await this._partyCore.close();
+    await this._protocol?.stop();
+
+    this._protocol = undefined;
+    this._invitationManager = undefined;
+
+    this.update.emit();
+
+    return this;
+  }
+
+  async createInvitation (authenticationDetails: InvitationAuthenticator, options?: InvitationOptions): Promise<InvitationDescriptor> {
+    assert(this._invitationManager, 'HALO party not open.');
+    return this._invitationManager.createInvitation(authenticationDetails, options);
   }
 }

package/src/halo/halo.test.ts

@@ -0,0 +1,198 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import expect from 'expect';
+import { it as test } from 'mocha';
+
+import { defaultSecretProvider, Keyring } from '@dxos/credentials';
+import { generateSeedPhrase, keyPairFromSeedPhrase, PublicKey } from '@dxos/crypto';
+import { codec } from '@dxos/echo-protocol';
+import { FeedStore } from '@dxos/feed-store';
+import { ModelFactory } from '@dxos/model-factory';
+import { NetworkManager } from '@dxos/network-manager';
+import { ObjectModel } from '@dxos/object-model';
+import { afterTest, testTimeout } from '@dxos/testutils';
+
+import { defaultInvitationAuthenticator } from '../invitations';
+import { MetadataStore, PartyFeedProvider } from '../pipeline';
+import { SnapshotStore } from '../snapshots';
+import { createRamStorage } from '../util';
+import { HALO } from './halo';
+
+describe('HALO', () => {
+  const setup = () => {
+    const modelFactory = new ModelFactory()
+      .registerModel(ObjectModel);
+
+    const networkManager = new NetworkManager();
+    const snapshotStore = new SnapshotStore(createRamStorage());
+    const metadataStore = new MetadataStore(createRamStorage());
+    const keyring = new Keyring();
+    const feedStore = new FeedStore(createRamStorage(), { valueEncoding: codec });
+
+    const feedProviderFactory = (partyKey: PublicKey) => new PartyFeedProvider(
+      metadataStore,
+      keyring,
+      feedStore,
+      partyKey
+    );
+
+    return new HALO({
+      keyring: keyring,
+      networkManager: networkManager,
+      metadataStore: metadataStore,
+      feedProviderFactory,
+      modelFactory: modelFactory,
+      snapshotStore: snapshotStore,
+      options: {}
+    });
+  };
+
+  const setupOpen = async () => {
+    const halo = setup();
+    await halo.open();
+    afterTest(() => halo.close());
+    return halo;
+  };
+
+  test('open & close', async () => {
+    const halo = setup();
+
+    await halo.open();
+    await halo.close();
+  });
+
+  test('create profile', async () => {
+    const halo = setup();
+    await halo.open();
+    afterTest(() => halo.close());
+
+    const profile = await halo.createProfile({ username: 'Test user' });
+    expect(profile.username).toEqual('Test user');
+    expect(profile.publicKey).toBeInstanceOf(PublicKey);
+  });
+
+  test('reload with profile', async () => {
+    const halo = setup();
+    await halo.open();
+
+    const initialProfile = await halo.createProfile({ username: 'Test user' });
+    await halo.close();
+
+    await halo.open();
+    const profile = halo.getProfile();
+    expect(profile).toBeDefined();
+    expect(profile!.username).toEqual('Test user');
+    expect(profile!.publicKey.equals(initialProfile.publicKey)).toBeTruthy();
+
+    await halo.close();
+  });
+
+  test('invite another device', async () => {
+    const deviceA = setup();
+    await deviceA.open();
+    afterTest(() => deviceA.close());
+    const profileA = await deviceA.createProfile({ username: 'Test user' });
+
+    const deviceB = setup();
+    await deviceB.open();
+    afterTest(() => deviceB.close());
+
+    const invitation = await deviceA.createInvitation(defaultInvitationAuthenticator);
+    await deviceB.join(invitation, defaultSecretProvider);
+
+    const profileB = deviceB.getProfile();
+    expect(profileB).toBeDefined();
+    expect(profileB!.username).toEqual('Test user');
+    expect(profileB!.publicKey.equals(profileA.publicKey)).toBeTruthy();
+  });
+
+  test('invite 2 devices in a chain', async () => {
+    const deviceA = await setupOpen();
+    const deviceB = await setupOpen();
+    const deviceC = await setupOpen();
+
+    const profileA = await deviceA.createProfile({ username: 'Test user' });
+
+    {
+      const invitation = await deviceA.createInvitation(defaultInvitationAuthenticator);
+      await deviceB.join(invitation, defaultSecretProvider);
+    }
+
+    {
+      const invitation = await deviceB.createInvitation(defaultInvitationAuthenticator);
+      await deviceC.join(invitation, defaultSecretProvider);
+    }
+
+    const profileC = deviceC.getProfile();
+    expect(profileC).toBeDefined();
+    expect(profileC!.username).toEqual('Test user');
+    expect(profileC!.publicKey.equals(profileA.publicKey)).toBeTruthy();
+  });
+
+  test('recover HALO', async () => {
+    const deviceA = await setupOpen();
+    const deviceB = await setupOpen();
+
+    const seedPhrase = generateSeedPhrase();
+    const profileA = await deviceA.createProfile({ username: 'Test user', ...keyPairFromSeedPhrase(seedPhrase) });
+
+    await deviceB.recover(seedPhrase);
+    const profileB = deviceB.getProfile();
+    expect(profileB).toBeDefined();
+    expect(profileB!.username).toEqual('Test user');
+    expect(profileB!.publicKey.equals(profileA.publicKey)).toBeTruthy();
+  });
+
+  test('HALO database is synced between 2 devices', async () => {
+    const deviceA = await setupOpen();
+    const deviceB = await setupOpen();
+    await deviceA.createProfile({ username: 'Test user' });
+    const invitation = await deviceA.createInvitation(defaultInvitationAuthenticator);
+    await deviceB.join(invitation, defaultSecretProvider);
+
+    {
+      const itemA = await deviceA.identity!.halo!.database.createItem({ type: 'example:test-1' });
+      const itemB = await testTimeout(deviceB.identity!.halo!.database.waitForItem({ type: 'example:test-1' }));
+      expect(itemA.id).toEqual(itemB.id);
+    }
+
+    {
+      const itemB = await deviceB.identity!.halo.database.createItem({ type: 'example:test-2' });
+      const itemA = await testTimeout(deviceA.identity!.halo.database.waitForItem({ type: 'example:test-2' }));
+      expect(itemB.id).toEqual(itemA.id);
+    }
+  });
+
+  describe('Preferences', () => {
+    test('global and device work on single device', async () => {
+      const halo = await setupOpen();
+      await halo.createProfile();
+
+      const globalPreferences: ObjectModel = halo.identity!.preferences!.getGlobalPreferences()!.model;
+      await globalPreferences.set('key', 'value');
+      expect(globalPreferences.get('key')).toEqual('value');
+
+      const devicePreferences: ObjectModel = halo.identity!.preferences!.getDevicePreferences()!.model;
+      await devicePreferences.set('key', 'value2');
+      expect(devicePreferences.get('key')).toEqual('value2');
+    });
+
+    test('global preferences are synced between devices', async () => {
+      const deviceA = await setupOpen();
+      const deviceB = await setupOpen();
+      await deviceA.createProfile({ username: 'Test user' });
+      const invitation = await deviceA.createInvitation(defaultInvitationAuthenticator);
+      await deviceB.join(invitation, defaultSecretProvider);
+
+      const preferencesA: ObjectModel = deviceA.identity!.preferences!.getGlobalPreferences()!.model;
+      const preferencesB: ObjectModel = deviceB.identity!.preferences!.getGlobalPreferences()!.model;
+
+      const update = preferencesB.update.waitForCount(1);
+      await preferencesA.set('key', 'value');
+      await testTimeout(update);
+      expect(preferencesB.get('key')).toEqual('value');
+    });
+  });
+});

package/src/halo/halo.ts

@@ -8,12 +8,15 @@ import debug from 'debug';
 import { synchronized } from '@dxos/async';
 import { KeyRecord, Keyring, KeyType, SecretProvider } from '@dxos/credentials';
 import { createKeyPair, KeyPair, PublicKey } from '@dxos/crypto';
+import { raise } from '@dxos/debug';
+import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 
 import { ResultSet } from '../api';
 import { InvitationAuthenticator, InvitationDescriptor, InvitationOptions } from '../invitations';
-import { MetadataStore } from '../metadata';
-import { PartyFactory, OpenProgress, PartyManager } from '../parties';
+import { OpenProgress } from '../parties';
+import { MetadataStore, PartyOptions, PartyFeedProvider } from '../pipeline';
+import { SnapshotStore } from '../snapshots';
 import { Contact } from './contact-manager';
 import { HaloFactory } from './halo-factory';
 import { IdentityManager } from './identity-manager';
@@ -28,10 +31,12 @@ export interface ProfileInfo {
 
 export interface HaloConfiguration {
   keyring: Keyring,
-  partyFactory: PartyFactory,
   networkManager: NetworkManager,
-  partyManager: PartyManager,
-  metadataStore: MetadataStore
+  metadataStore: MetadataStore,
+  modelFactory: ModelFactory,
+  snapshotStore: SnapshotStore,
+  feedProviderFactory: (partyKey: PublicKey) => PartyFeedProvider,
+  options: PartyOptions
 }
 
 /**
@@ -39,23 +44,26 @@ export interface HaloConfiguration {
  */
 export class HALO {
   private readonly _keyring: Keyring;
-  private readonly _partyManager: PartyManager;
   private readonly _identityManager: IdentityManager;
 
   constructor ({
     keyring,
-    partyManager,
-    partyFactory,
     networkManager,
-    metadataStore
+    metadataStore,
+    modelFactory,
+    snapshotStore,
+    feedProviderFactory,
+    options
   }: HaloConfiguration) {
     this._keyring = keyring;
-    this._partyManager = partyManager;
 
     const haloFactory = new HaloFactory(
-      partyFactory,
       networkManager,
-      this._keyring
+      modelFactory,
+      snapshotStore,
+      feedProviderFactory,
+      keyring,
+      options
     );
 
     this._identityManager = new IdentityManager(this._keyring, haloFactory, metadataStore);
@@ -98,7 +106,7 @@ export class HALO {
    * User's IDENTITY keypair.
    */
   get identityKey (): KeyRecord | undefined {
-    return this.identity.identityKey;
+    return this.identity?.identityKey;
   }
 
   /**
@@ -106,7 +114,7 @@ export class HALO {
    */
   // TODO(burdon): Rename username (here and in data structure).
   get identityDisplayName (): string | undefined {
-    return this.identity.displayName;
+    return this.identity?.displayName;
   }
 
   /**
@@ -135,8 +143,7 @@ export class HALO {
    * Closes HALO. Automatically called when client is destroyed.
    */
   async close () {
-    // TODO(marik-d): Should be `_identityManager.close()`.
-    await this.identity.halo?.close();
+    await this._identityManager.close();
   }
 
   /**
@@ -155,13 +162,12 @@ export class HALO {
    *
    * NOTE: This method does not initialize the HALO party.
    */
-  // TODO(burdon): Why is this separate from createHalo?
-  async createIdentity (keyPair: KeyPair) {
+  private async _createIdentityKeypair (keyPair: KeyPair) {
     const { publicKey, secretKey } = keyPair;
     assert(publicKey, 'Invalid publicKey');
     assert(secretKey, 'Invalid secretKey');
 
-    if (this.identity.identityKey) {
+    if (this.identity?.identityKey) {
       // TODO(burdon): Bad API: Semantics change based on options.
       // TODO(burdon): `createProfile` isn't part of this package.
       throw new Error('Identity key already exists. Call createProfile without a keypair to only create a halo party.');
@@ -173,28 +179,25 @@ export class HALO {
   /**
    * Creates the initial HALO party.
    */
-  // TODO(burdon): Return Halo API object?
-  async create (displayName?: string) {
+  private async _createHaloParty (displayName?: string) {
     // TODO(burdon): Why not assert?
-    if (this.identity.halo) {
-      throw new Error('HALO party already exists');
-    }
-    if (!this.identity.identityKey) {
-      throw new Error('Cannot create HALO. Identity key not found.');
+    if (this.identity) {
+      throw new Error('Identity already initialized');
     }
 
+    const identityKey = this._identityManager.getIdentityKey() ?? raise(new Error('Cannot create HALO. Identity key not found.'));
     await this._identityManager.createHalo({
-      identityDisplayName: displayName || this.identity.identityKey.publicKey.humanize()
+      identityDisplayName: displayName || identityKey.publicKey.humanize()
     });
   }
 
   /**
    * Joins an existing identity HALO from a recovery seed phrase.
    */
+  // TODO(dmaretskyi): Do not return HALO party here.
   async recover (seedPhrase: string) {
-    assert(this._partyManager.isOpen, 'ECHO not open.');
-    assert(!this.identity.halo, 'HALO already exists.');
-    assert(!this.identity.identityKey, 'Identity key already exists.');
+    assert(!this.identity?.halo, 'HALO already exists.');
+    assert(!this.identity?.identityKey, 'Identity key already exists.');
 
     return this._identityManager.recoverHalo(seedPhrase);
   }
@@ -202,9 +205,9 @@ export class HALO {
   /**
    * Joins an existing identity HALO by invitation.
    */
+  // TODO(dmaretskyi): Do not return HALO party here.
   async join (invitationDescriptor: InvitationDescriptor, secretProvider: SecretProvider) {
-    assert(this._partyManager.isOpen, 'ECHO not open.');
-    assert(!this.identity.halo, 'HALO already exists.');
+    assert(!this.identity?.halo, 'HALO already exists.');
 
     return this._identityManager.joinHalo(invitationDescriptor, secretProvider);
   }
@@ -213,9 +216,8 @@ export class HALO {
    * Create an invitation to an exiting identity HALO.
    */
   async createInvitation (authenticationDetails: InvitationAuthenticator, options?: InvitationOptions) {
-    assert(this.identity.halo, 'HALO not initialized.');
-
-    return this.identity.halo.invitationManager.createInvitation(authenticationDetails, options);
+    assert(this.identity?.halo, 'HALO not initialized.');
+    return this.identity.halo.createInvitation(authenticationDetails, options);
   }
 
   /**
@@ -223,7 +225,7 @@ export class HALO {
    */
   // TODO(burdon): Expose ContactManager directly.
   queryContacts (): ResultSet<Contact> {
-    assert(this.identity.contacts, 'HALO not initialized.');
+    assert(this.identity?.contacts, 'HALO not initialized.');
 
     return this.identity.contacts.queryContacts();
   }
@@ -245,8 +247,8 @@ export class HALO {
     }
 
     const keyPair = publicKey ? { publicKey: Buffer.from(publicKey), secretKey: Buffer.from(secretKey!) } : createKeyPair();
-    await this.createIdentity(keyPair);
-    await this.create(username);
+    await this._createIdentityKeypair(keyPair);
+    await this._createHaloParty(username);
 
     const profile = this.getProfile();
     assert(profile);