@dxos/echo-db 2.33.1 → 2.33.2-dev.18eaaced

package/src/echo.ts

@@ -9,7 +9,7 @@ import memdown from 'memdown';
 import { synchronized } from '@dxos/async';
 import { Keyring, KeyStore, SecretProvider } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-import { InvalidStateError } from '@dxos/debug';
+import { InvalidStateError, raise } from '@dxos/debug';
 import { codec, DataService, PartyKey, PartySnapshot } from '@dxos/echo-protocol';
 import { FeedStore } from '@dxos/feed-store';
 import { ModelFactory } from '@dxos/model-factory';
@@ -20,13 +20,12 @@ import { SubscriptionGroup } from '@dxos/util';
 
 import { ResultSet } from './api';
 import { DataServiceRouter } from './database';
-import { InvalidStorageVersionError } from './errors';
+import { IdentityNotInitializedError, InvalidStorageVersionError } from './errors';
 import { HALO } from './halo';
 import { autoPartyOpener } from './halo/party-opener';
 import { InvitationDescriptor, OfflineInvitationClaimer } from './invitations';
-import { MetadataStore, STORAGE_VERSION } from './metadata';
-import { OpenProgress, PartyFactory, PartyInternal, PartyManager } from './parties';
-import { PartyFeedProvider } from './pipeline';
+import { OpenProgress, PartyFactory, DataParty, PartyManager } from './parties';
+import { MetadataStore, STORAGE_VERSION, PartyFeedProvider } from './pipeline';
 import { SnapshotStore } from './snapshots';
 import { createRamStorage } from './util';
 
@@ -34,7 +33,7 @@ const log = debug('dxos:echo');
 const error = log.extend('error');
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface PartyFilter {}
+export interface PartyFilter { }
 
 /**
  * Various options passed to `ECHO.create`.
@@ -133,7 +132,7 @@ export class ECHO {
     this._keyring = new Keyring(new KeyStore(keyStorage));
     this._feedStore = new FeedStore(feedStorage, { valueEncoding: codec });
 
-    const createFeedProvider = (partyKey: PublicKey) => new PartyFeedProvider(
+    const feedProviderFactory = (partyKey: PublicKey) => new PartyFeedProvider(
       this._metadataStore,
       this._keyring,
       this._feedStore,
@@ -153,7 +152,7 @@ export class ECHO {
       this._networkManager,
       this._modelFactory,
       this._snapshotStore,
-      createFeedProvider,
+      feedProviderFactory,
       options
     );
 
@@ -164,18 +163,19 @@ export class ECHO {
       partyFactory
     );
 
-    // TODO(burdon): Why does this need both PartyManager and PartyFactory?
     this._halo = new HALO({
       keyring: this._keyring,
-      partyManager: this._partyManager,
-      partyFactory,
       networkManager: this._networkManager,
-      metadataStore: this._metadataStore
+      metadataStore: this._metadataStore,
+      feedProviderFactory: feedProviderFactory,
+      modelFactory: this._modelFactory,
+      snapshotStore: this._snapshotStore,
+      options
     });
 
     this._halo.identityReady.once(() => {
       // It might be the case that halo gets closed before this has a chance to execute.
-      if (this.halo.identity.halo?.isOpen) {
+      if (this.halo.identity?.halo.isOpen) {
         this._subs.push(autoPartyOpener(this.halo.identity.preferences!, this._partyManager));
       }
     });
@@ -260,7 +260,7 @@ export class ECHO {
   /**
    * Closes the ECHO instance.
    */
-   @synchronized
+  @synchronized
   async close () {
     if (!this.isOpen) {
       return;
@@ -268,10 +268,8 @@ export class ECHO {
 
     this._subs.unsubscribe();
 
-    // TODO(marik-d): Should be `_identityManager.close()`.
     await this.halo.close();
 
-    // TODO(marik-d): Close network manager.
     await this._partyManager.close();
 
     await this._feedStore.close();
@@ -279,107 +277,107 @@ export class ECHO {
     await this.networkManager.destroy();
   }
 
-   /**
-   * Removes all data and closes this ECHO instance.
-   *
-   * The instance will be in an unusable state at this point and a page refresh is recommended.
-   */
-   // TODO(burdon): Enable re-open.
-   async reset () {
-     await this.close();
-
-     try {
-       if (this._feedStore.storage.destroy) {
-         await this._feedStore.storage.destroy();
-       }
-     } catch (err: any) {
-       error('Error clearing feed storage:', err);
-     }
-
-     await this.halo.reset();
-
-     try {
-       await this._snapshotStore.clear();
-     } catch (err: any) {
-       error('Error clearing snapshot storage:', err);
-     }
-
-     try {
-       await this._metadataStore.clear();
-     } catch (err: any) {
-       error('Error clearing metadata storage:', err);
-     }
-   }
-
-   //
-   // Parties.
-   //
-
-   /**
+  /**
+  * Removes all data and closes this ECHO instance.
+  *
+  * The instance will be in an unusable state at this point and a page refresh is recommended.
+  */
+  // TODO(burdon): Enable re-open.
+  async reset () {
+    await this.close();
+
+    try {
+      if (this._feedStore.storage.destroy) {
+        await this._feedStore.storage.destroy();
+      }
+    } catch (err: any) {
+      error('Error clearing feed storage:', err);
+    }
+
+    await this.halo.reset();
+
+    try {
+      await this._snapshotStore.clear();
+    } catch (err: any) {
+      error('Error clearing snapshot storage:', err);
+    }
+
+    try {
+      await this._metadataStore.clear();
+    } catch (err: any) {
+      error('Error clearing metadata storage:', err);
+    }
+  }
+
+  //
+  // Parties.
+  //
+
+  /**
    * Creates a new party.
    */
-   async createParty (): Promise<PartyInternal> {
-     await this.open();
+  async createParty (): Promise<DataParty> {
+    await this.open();
+
+    const party = await this._partyManager.createParty();
+    await party.open();
 
-     const party = await this._partyManager.createParty();
-     await party.open();
+    return party;
+  }
 
-     return party;
-   }
+  /**
+  * Clones an existing party from a snapshot.
+  * @param snapshot
+  */
+  async cloneParty (snapshot: PartySnapshot) {
+    await this.open();
 
-   /**
-   * Clones an existing party from a snapshot.
-   * @param snapshot
-   */
-   async cloneParty (snapshot: PartySnapshot) {
-     await this.open();
+    const party = await this._partyManager.cloneParty(snapshot);
+    await party.open();
 
-     const party = await this._partyManager.cloneParty(snapshot);
-     await party.open();
+    return party;
+  }
 
-     return party;
-   }
+  /**
+  * Returns an individual party by it's key.
+  * @param {PartyKey} partyKey
+  */
+  getParty (partyKey: PartyKey): DataParty | undefined {
+    if (!this._partyManager.isOpen) {
+      throw new InvalidStateError();
+    }
 
-   /**
-   * Returns an individual party by it's key.
-   * @param {PartyKey} partyKey
-   */
-   getParty (partyKey: PartyKey): PartyInternal | undefined {
-     if (!this._partyManager.isOpen) {
-       throw new InvalidStateError();
-     }
-
-     const party = this._partyManager.parties.find(party => party.key.equals(partyKey));
-     return party;
-   }
-
-   /**
-   * Queries for a set of Parties matching the optional filter.
-   * @param {PartyFilter} filter
-   */
-   // eslint-disable-next-line unused-imports/no-unused-vars
-   queryParties (filter?: PartyFilter): ResultSet<PartyInternal> {
-     if (!this._partyManager.isOpen) {
-       throw new InvalidStateError();
-     }
-
-     return new ResultSet(
-       this._partyManager.update.discardParameter(),
-       () => this._partyManager.parties
-     );
-   }
-
-   /**
-   * Joins a party that was created by another peer and starts replicating with it.
-   * @param invitationDescriptor Invitation descriptor passed from another peer.
-   * @param secretProvider Shared secret provider, the other peer creating the invitation must have the same secret.
-   */
-   async joinParty (invitationDescriptor: InvitationDescriptor, secretProvider?: SecretProvider): Promise<PartyInternal> {
-     assert(this._partyManager.isOpen, new InvalidStateError());
+    const party = this._partyManager.parties.find(party => party.key.equals(partyKey));
+    return party;
+  }
 
-     const actualSecretProvider =
-      secretProvider ?? OfflineInvitationClaimer.createSecretProvider(this.halo.identity);
+  /**
+  * Queries for a set of Parties matching the optional filter.
+  * @param {PartyFilter} filter
+  */
+  // eslint-disable-next-line unused-imports/no-unused-vars
+  queryParties (filter?: PartyFilter): ResultSet<DataParty> {
+    if (!this._partyManager.isOpen) {
+      throw new InvalidStateError();
+    }
+
+    return new ResultSet(
+      this._partyManager.update.discardParameter(),
+      () => this._partyManager.parties
+    );
+  }
 
-     return this._partyManager.joinParty(invitationDescriptor, actualSecretProvider);
-   }
+  /**
+  * Joins a party that was created by another peer and starts replicating with it.
+  * @param invitationDescriptor Invitation descriptor passed from another peer.
+  * @param secretProvider Shared secret provider, the other peer creating the invitation must have the same secret.
+  */
+  async joinParty (invitationDescriptor: InvitationDescriptor, secretProvider?: SecretProvider): Promise<DataParty> {
+    assert(this._partyManager.isOpen, new InvalidStateError());
+
+    const actualSecretProvider =
+      secretProvider ?? OfflineInvitationClaimer.createSecretProvider(this.halo.identity ?? raise(new IdentityNotInitializedError()));
+
+    return this._partyManager.joinParty(invitationDescriptor, actualSecretProvider);
+  }
 }

package/src/halo/contact-manager.ts

@@ -4,10 +4,12 @@
 
 import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/crypto';
+import { raise } from '@dxos/debug';
 import { ObjectModel } from '@dxos/object-model';
 
-import { Item, ResultSet } from '../api';
-import { PartyInternal, PartyMember } from '../parties';
+import { Database, Item, ResultSet } from '../api';
+import { IdentityNotInitializedError } from '../errors';
+import { PartyMember } from '../parties';
 import { HALO_PARTY_CONTACT_LIST_TYPE } from './halo-party';
 
 // TODO(burdon): Create different class (additional properties).
@@ -18,16 +20,18 @@ export type Contact = PartyMember;
  */
 export class ContactManager {
   constructor (
-    private readonly _party: PartyInternal
+    private readonly _getDatabase: () => Database | undefined
   ) {}
 
   getContactListItem (): Item<ObjectModel> | undefined {
-    return this._party.database.select({ type: HALO_PARTY_CONTACT_LIST_TYPE }).exec().entities[0];
+    const database = this._getDatabase() ?? raise(new IdentityNotInitializedError());
+    return database.select({ type: HALO_PARTY_CONTACT_LIST_TYPE }).exec().entities[0];
   }
 
   queryContacts (): ResultSet<Contact> {
+    const database = this._getDatabase() ?? raise(new IdentityNotInitializedError());
     const event = new Event();
-    const result = this._party.database.select({ type: HALO_PARTY_CONTACT_LIST_TYPE }).exec();
+    const result = database.select({ type: HALO_PARTY_CONTACT_LIST_TYPE }).exec();
     result.update.on(() => {
       event.emit();
     });

package/src/halo/halo-factory.ts

@@ -13,18 +13,24 @@ import {
   Keyring,
   KeyType,
   Filter,
-  SecretProvider
+  SecretProvider,
+  KeyHint,
+  createFeedAdmitMessage
 } from '@dxos/credentials';
 import { keyToString, PublicKey, keyPairFromSeedPhrase } from '@dxos/crypto';
+import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 
-import { HaloRecoveryInitiator, InvitationDescriptor } from '../invitations';
-import { PartyFactory, PartyInternal, PARTY_ITEM_TYPE } from '../parties';
+import { createHaloPartyAdmissionMessage, GreetingInitiator, HaloRecoveryInitiator, InvitationDescriptor, InvitationDescriptorType, OfflineInvitationClaimer } from '../invitations';
+import { PARTY_ITEM_TYPE } from '../parties';
+import { PartyFeedProvider, PartyOptions } from '../pipeline';
+import { CredentialsSigner } from '../protocol/credentials-signer';
+import { SnapshotStore } from '../snapshots';
 import {
+  HaloParty,
   HALO_PARTY_CONTACT_LIST_TYPE, HALO_PARTY_DEVICE_PREFERENCES_TYPE, HALO_PARTY_PREFERENCES_TYPE
 } from './halo-party';
-import { Identity } from './identity';
 
 /**
  * Options allowed when creating the HALO.
@@ -41,16 +47,32 @@ const log = debug('dxos:echo-db:halo-factory');
  */
 export class HaloFactory {
   constructor (
-    private readonly _partyFactory: PartyFactory,
     private readonly _networkManager: NetworkManager,
-    private readonly _keyring: Keyring
+    private readonly _modelFactory: ModelFactory,
+    private readonly _snapshotStore: SnapshotStore,
+    private readonly _feedProviderFactory: (partyKey: PublicKey) => PartyFeedProvider,
+    private readonly _keyring: Keyring,
+    private readonly _options: PartyOptions = {}
   ) {}
 
-  async constructParty (partyKey: PublicKey) {
-    return this._partyFactory.constructParty(partyKey);
+  async constructParty (hints: KeyHint[]): Promise<HaloParty> {
+    const credentialsSigner = CredentialsSigner.createDirectDeviceSigner(this._keyring);
+    const feedProvider = this._feedProviderFactory(credentialsSigner.getIdentityKey().publicKey);
+    const halo = new HaloParty(
+      this._modelFactory,
+      this._snapshotStore,
+      feedProvider,
+      credentialsSigner,
+      this._networkManager,
+      hints,
+      undefined,
+      this._options
+    );
+
+    return halo;
   }
 
-  async createHalo (options: HaloCreationOptions = {}): Promise<PartyInternal> {
+  async createHalo (options: HaloCreationOptions = {}): Promise<HaloParty> {
     // Don't use `identityManager.identityKey`, because that doesn't check for the secretKey.
     const identityKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.IDENTITY }));
     assert(identityKey, 'Identity key required.');
@@ -59,8 +81,10 @@ export class HaloFactory {
       await this._keyring.createKeyRecord({ type: KeyType.DEVICE });
 
     // 1. Create a feed for the HALO.
-    const halo = await this._partyFactory.constructParty(identityKey.publicKey);
-    const { feed } = await halo.feedProvider.createOrOpenWritableFeed();
+    const halo = await this.constructParty([]);
+    const feedKey = await halo.getWriteFeedKey();
+    const feedKeyPair = this._keyring.getKey(feedKey);
+    assert(feedKeyPair);
 
     // Connect the pipeline.
     await halo.open();
@@ -70,8 +94,6 @@ export class HaloFactory {
      *    B. Device key (the first "member" of the Identity's HALO).
      *    C. Feed key (the feed owned by the Device).
      */
-    const feedKeyPair = this._keyring.getKey(feed.key);
-    assert(feedKeyPair);
     await halo.processor.writeHaloMessage(createPartyGenesisMessage(this._keyring, identityKey, feedKeyPair.publicKey, deviceKey));
 
     /* 3. Make a special self-signed KeyAdmit message which will serve as an "IdentityGenesis" message. This
@@ -105,15 +127,16 @@ export class HaloFactory {
     return halo;
   }
 
-  async recoverHalo (identity: Identity, seedPhrase: string) {
+  async recoverHalo (seedPhrase: string) {
     const recoveredKeyPair = keyPairFromSeedPhrase(seedPhrase);
     await this._keyring.addKeyRecord({
       publicKey: PublicKey.from(recoveredKeyPair.publicKey),
       secretKey: recoveredKeyPair.secretKey,
       type: KeyType.IDENTITY
     });
+    await this._keyring.createKeyRecord({ type: KeyType.DEVICE });
 
-    const recoverer = new HaloRecoveryInitiator(this._networkManager, identity);
+    const recoverer = new HaloRecoveryInitiator(this._networkManager, CredentialsSigner.createDirectDeviceSigner(this._keyring));
     await recoverer.connect();
 
     const invitationDescriptor = await recoverer.claim();
@@ -122,7 +145,7 @@ export class HaloFactory {
   }
 
   async joinHalo (invitationDescriptor: InvitationDescriptor, secretProvider: SecretProvider) {
-    assert(!this._keyring.findKey(Filter.matches({ type: KeyType.PARTY })), 'Identity key must NOT exist.');
+    assert(!this._keyring.findKey(Filter.matches({ type: KeyType.IDENTITY })), 'Identity key must not exist.');
 
     return this._joinHalo(invitationDescriptor, secretProvider);
   }
@@ -131,9 +154,9 @@ export class HaloFactory {
     log(`Admitting device with invitation: ${keyToString(invitationDescriptor.invitation)}`);
     assert(invitationDescriptor.identityKey);
 
-    const identityKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.IDENTITY }));
+    let identityKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.IDENTITY }));
     if (!identityKey) {
-      await this._keyring.addPublicKey({
+      identityKey = await this._keyring.addPublicKey({
         type: KeyType.IDENTITY,
         publicKey: invitationDescriptor.identityKey,
         own: true,
@@ -143,11 +166,51 @@ export class HaloFactory {
       assert(identityKey.publicKey.equals(invitationDescriptor.identityKey),
         'Identity key must match invitation');
     }
+    assert(identityKey);
 
     const deviceKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.DEVICE })) ??
       await this._keyring.createKeyRecord({ type: KeyType.DEVICE });
 
-    const halo = await this._partyFactory.joinParty(invitationDescriptor, secretProvider);
+    const originalInvitation = invitationDescriptor;
+
+    const credentialsSigner = CredentialsSigner.createDirectDeviceSigner(this._keyring);
+    // Claim the offline invitation and convert it into an interactive invitation.
+    if (invitationDescriptor.type === InvitationDescriptorType.OFFLINE) {
+      const invitationClaimer = new OfflineInvitationClaimer(this._networkManager, invitationDescriptor);
+      await invitationClaimer.connect();
+      invitationDescriptor = await invitationClaimer.claim();
+      log(`Party invitation triggered interactive Greeting at: ${JSON.stringify({ original: originalInvitation.invitation, interactive: invitationDescriptor.invitation })}`);
+      await invitationClaimer.destroy();
+    }
+
+    const initiator = new GreetingInitiator(
+      this._networkManager,
+      invitationDescriptor,
+      async (partyKey, nonce) => {
+        assert(partyKey.equals(identityKey!.publicKey));
+        return [createHaloPartyAdmissionMessage(credentialsSigner, nonce)];
+      }
+    );
+
+    await initiator.connect();
+    const { partyKey, hints } = await initiator.redeemInvitation(secretProvider);
+
+    /*
+     * TODO(telackey): We shouldn't have to add our key here, it should be in the hints, but our hint
+     * mechanism is broken by not waiting on the messages to be processed before returning.
+     */
+    const halo = await this.constructParty(hints);
+    await halo.open();
+
+    // Write the Feed genesis message.
+    await halo.processor.writeHaloMessage(createFeedAdmitMessage(
+      credentialsSigner.signer,
+      partyKey,
+      await halo.getWriteFeedKey(),
+      [credentialsSigner.getDeviceKey()]
+    ));
+    await initiator.destroy();
+
     await halo.database.createItem({
       model: ObjectModel,
       type: HALO_PARTY_DEVICE_PREFERENCES_TYPE,