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

package/src/invitations/{invitation-manager.ts → invitation-factory.ts}

@@ -8,8 +8,8 @@ import { createPartyInvitationMessage } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { NetworkManager } from '@dxos/network-manager';
 
-import { IdentityProvider } from '../halo';
 import { PartyProcessor } from '../pipeline';
+import { CredentialsSigner } from '../protocol/credentials-signer';
 import { defaultInvitationAuthenticator, InvitationAuthenticator, InvitationOptions } from './common';
 import { GreetingResponder } from './greeting-responder';
 import { InvitationDescriptor, InvitationDescriptorType } from './invitation-descriptor';
@@ -17,36 +17,29 @@ import { InvitationDescriptor, InvitationDescriptorType } from './invitation-des
 /**
  * Groups together all invitation-related functionality for a single party.
  */
-export class InvitationManager {
+export class InvitationFactory {
   constructor (
     private readonly _partyProcessor: PartyProcessor,
     // This needs to be a provider in case this is a backend for the HALO party.
     // Then the identity would be changed after this is instantiated.
-    private readonly _identityProvider: IdentityProvider,
+    private readonly _credentialsSigner: CredentialsSigner,
     private readonly _networkManager: NetworkManager
   ) {}
 
-  private get _identity () {
-    return this._identityProvider();
-  }
-
   get isHalo () {
     // The PartyKey of the HALO is the Identity key.
-    assert(this._identity.identityKey, 'No identity key.');
-    return this._identity.identityKey.publicKey.equals(this._partyProcessor.partyKey);
+    return this._credentialsSigner.getIdentityKey().publicKey.equals(this._partyProcessor.partyKey);
   }
 
   async createOfflineInvitation (publicKey: PublicKey) {
     assert(!this.isHalo, 'Offline invitations to HALO are not allowed.');
-    assert(this._identity.identityKey, 'Identity key is required.');
-    assert(this._identity.deviceKeyChain, 'Device keychain is required.');
 
     const invitationMessage = createPartyInvitationMessage(
-      this._identity.signer,
+      this._credentialsSigner.signer,
       this._partyProcessor.partyKey,
       publicKey,
-      this._identity.identityKey,
-      this._identity.deviceKeyChain
+      this._credentialsSigner.getIdentityKey(),
+      this._credentialsSigner.getDeviceSigningKeys()
     );
 
     await this._partyProcessor.writeHaloMessage(invitationMessage);
@@ -67,7 +60,7 @@ export class InvitationManager {
     const responder = new GreetingResponder(
       this._networkManager,
       this._partyProcessor,
-      this._identity
+      this._credentialsSigner
     );
 
     const { secretValidator, secretProvider } = authenticationDetails;

package/src/invitations/offline-invitation-claimer.ts

@@ -29,7 +29,7 @@ import { Identity } from '../halo';
 import { greetingProtocolProvider } from './greeting-protocol-provider';
 import { GreetingState } from './greeting-responder';
 import { InvitationDescriptor, InvitationDescriptorType } from './invitation-descriptor';
-import { InvitationManager } from './invitation-manager';
+import { InvitationFactory } from './invitation-factory';
 
 const log = debug('dxos:party-manager:party-invitation-claimer');
 
@@ -132,9 +132,9 @@ export class OfflineInvitationClaimer {
   /**
    * Create a function for handling PartyInvitation claims on the indicated Party. This is used by members
    * of the Party for responding to attempts to claim an Invitation which has been written to the Party.
-   * @param {InvitationManager} invitationManager
+   * @param {InvitationFactory} invitationManager
    */
-  static createOfflineInvitationClaimHandler (invitationManager: InvitationManager) {
+  static createOfflineInvitationClaimHandler (invitationManager: InvitationFactory) {
     const claimHandler = new PartyInvitationClaimHandler(async (invitationID: Buffer) => {
       const invitationMessage = invitationManager.getOfflineInvitation(invitationID);
       if (!invitationMessage) {

package/src/parties/{party-internal.ts → data-party.ts}

@@ -5,22 +5,21 @@
 import assert from 'assert';
 
 import { synchronized, Event } from '@dxos/async';
-import { KeyHint, createAuthMessage, createFeedAdmitMessage, codec } from '@dxos/credentials';
+import { KeyHint } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-import { failUndefined, raise, timed } from '@dxos/debug';
-import { PartyKey, PartySnapshot, Timeframe, FeedKey } from '@dxos/echo-protocol';
+import { timed } from '@dxos/debug';
+import { PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 
 import { Database, Item, ResultSet } from '../api';
-import { IdentityNotInitializedError } from '../errors';
-import { ActivationOptions, PartyPreferences, IdentityProvider } from '../halo';
-import { InvitationManager } from '../invitations';
-import { CredentialsProvider, PartyFeedProvider, PartyProtocolFactory } from '../pipeline';
+import { ActivationOptions, PartyPreferences, Preferences } from '../halo';
+import { InvitationFactory } from '../invitations';
+import { PartyFeedProvider, PartyProtocolFactory, PartyCore, PartyOptions } from '../pipeline';
+import { createAuthPlugin, createOfflineInvitationPlugin, createAuthenticator, createCredentialsProvider } from '../protocol';
+import { CredentialsSigner } from '../protocol/credentials-signer';
 import { SnapshotStore } from '../snapshots';
-import { createAuthenticator } from './authenticator';
-import { PartyCore, PartyOptions } from './party-core';
 import { CONTACT_DEBOUNCE_INTERVAL } from './party-manager';
 
 export const PARTY_ITEM_TYPE = 'dxos:item/party';
@@ -34,14 +33,16 @@ export interface PartyMember {
 }
 
 /**
- * TODO(burdon): Comment.
+ * Generic parties that peers create that is capable of storing data in the database.
+ *
+ * This class handles data-storage, replication, snapshots, access-control, and invitations.
  */
-export class PartyInternal {
+export class DataParty {
   public readonly update = new Event<void>();
 
   private readonly _partyCore: PartyCore;
   private readonly _preferences?: PartyPreferences;
-  private _invitationManager?: InvitationManager;
+  private _invitationManager?: InvitationFactory;
   private _protocol?: PartyProtocolFactory;
 
   constructor (
@@ -49,28 +50,27 @@ export class PartyInternal {
     modelFactory: ModelFactory,
     snapshotStore: SnapshotStore,
     private readonly _feedProvider: PartyFeedProvider,
-    // This needs to be a provider in case this is a backend for the HALO party.
-    // Then the identity would be changed after this is instantiated.
-    private readonly _identityProvider: IdentityProvider,
+    private readonly _credentialsSigner: CredentialsSigner,
+    // TODO(dmaretskyi): Pull this out to a higher level. Should preferences be part of client API instead?
+    private readonly _profilePreferences: Preferences | undefined,
     private readonly _networkManager: NetworkManager,
     private readonly _hints: KeyHint[] = [],
     _initialTimeframe?: Timeframe,
     _options: PartyOptions = {}
   ) {
-    const identity = this._identityProvider();
-
     this._partyCore = new PartyCore(
       partyKey,
       _feedProvider,
       modelFactory,
       snapshotStore,
-      identity.identityKey?.publicKey ?? failUndefined(),
+      this._credentialsSigner.getIdentityKey().publicKey,
       _initialTimeframe,
       _options
     );
 
-    if (identity.preferences) {
-      this._preferences = new PartyPreferences(identity.preferences, this);
+    // TODO(dmaretskyi): Pull this out to a higher level. Should preferences be part of client API instead?
+    if (this._profilePreferences) {
+      this._preferences = new PartyPreferences(this._profilePreferences, this);
     }
   }
 
@@ -155,36 +155,34 @@ export class PartyInternal {
       return this;
     }
 
-    const identity = this._identityProvider();
-    assert(identity.deviceKey, 'Missing device key.');
-
     await this._partyCore.open(this._hints);
 
-    this._invitationManager = new InvitationManager(
+    this._invitationManager = new InvitationFactory(
       this._partyCore.processor,
-      this._identityProvider,
+      this._credentialsSigner,
       this._networkManager
     );
 
     //
     // Network/swarm.
+    // Replication, invitations, and authentication functions.
     //
 
+    const deviceKey = this._credentialsSigner.getDeviceKey();
     const writeFeed = await this._partyCore.getWriteFeed();
-
     this._protocol = new PartyProtocolFactory(
       this._partyCore.key,
       this._networkManager,
       this._feedProvider,
-      this._identityProvider,
-      this._createCredentialsProvider(this._partyCore.key, writeFeed.key),
-      this._invitationManager,
-      createAuthenticator(this._partyCore.processor, this._identityProvider),
+      deviceKey.publicKey,
+      createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key),
       this._partyCore.processor.getActiveFeedSet()
     );
 
-    // Replication.
-    await this._protocol.start();
+    await this._protocol.start([
+      createAuthPlugin(createAuthenticator(this._partyCore.processor, this._credentialsSigner), deviceKey.publicKey),
+      createOfflineInvitationPlugin(this._invitationManager, deviceKey.publicKey)
+    ]);
 
     // Issue an 'update' whenever the properties change.
     this.database.select({ type: PARTY_ITEM_TYPE }).exec().update.on(() => this.update.emit());
@@ -271,29 +269,6 @@ export class PartyInternal {
     await this._partyCore.restoreFromSnapshot(snapshot);
   }
 
-  private _createCredentialsProvider (partyKey: PartyKey, feedKey: FeedKey): CredentialsProvider {
-    return {
-      get: () => {
-        const identity = this._identityProvider();
-        const signingKey = identity.deviceKeyChain ?? identity.deviceKey ?? raise(new IdentityNotInitializedError());
-        return Buffer.from(codec.encode(createAuthMessage(
-          identity.signer,
-          partyKey,
-          identity.identityKey ?? raise(new IdentityNotInitializedError()),
-          signingKey,
-          identity.keyring.getKey(feedKey),
-          undefined,
-          createFeedAdmitMessage(
-            identity.signer,
-            partyKey,
-            feedKey,
-            [identity.keyring.getKey(feedKey) ?? failUndefined(), signingKey]
-          )
-        )));
-      }
-    };
-  }
-
   /**
    * Get all party members.
    */

package/src/parties/index.ts

@@ -2,7 +2,6 @@
 // Copyright 2020 DXOS.org
 //
 
-export * from './party-core';
 export * from './party-factory';
-export * from './party-internal';
+export * from './data-party';
 export * from './party-manager';

package/src/parties/party-factory.ts

@@ -15,20 +15,21 @@ import {
   wrapMessage
 } from '@dxos/credentials';
 import { humanize, keyToString, PublicKey } from '@dxos/crypto';
-import { failUndefined, timed } from '@dxos/debug';
+import { failUndefined, raise, timed } from '@dxos/debug';
 import { createFeedWriter, FeedMessage, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 
+import { IdentityNotInitializedError } from '../errors';
 import { IdentityProvider } from '../halo';
 import {
+  createDataPartyAdmissionMessages,
   GreetingInitiator, InvitationDescriptor, InvitationDescriptorType, OfflineInvitationClaimer
 } from '../invitations';
-import { PartyFeedProvider } from '../pipeline';
+import { PartyFeedProvider, PartyOptions } from '../pipeline';
 import { SnapshotStore } from '../snapshots';
-import { PartyOptions } from './party-core';
-import { PartyInternal, PARTY_ITEM_TYPE } from './party-internal';
+import { DataParty, PARTY_ITEM_TYPE } from './data-party';
 
 const log = debug('dxos:echo-db:party-factory');
 
@@ -41,7 +42,7 @@ export class PartyFactory {
     private readonly _networkManager: NetworkManager,
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
-    private readonly _createFeedProvider: (partyKey: PublicKey) => PartyFeedProvider,
+    private readonly _feedProviderFactory: (partyKey: PublicKey) => PartyFeedProvider,
     private readonly _options: PartyOptions = {}
   ) {}
 
@@ -49,8 +50,8 @@ export class PartyFactory {
    * Create a new party with a new feed for it. Writes a party genensis message to this feed.
    */
   @timed(5_000)
-  async createParty (): Promise<PartyInternal> {
-    const identity = this._identityProvider();
+  async createParty (): Promise<DataParty> {
+    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
     assert(identity.identityGenesis, 'HALO not initialized.');
     assert(identity.deviceKeyChain, 'Device KeyChain not initialized.');
     assert(!this._options.readOnly, 'PartyFactory is read-only.');
@@ -112,25 +113,26 @@ export class PartyFactory {
    * @param hints
    */
   async addParty (partyKey: PartyKey, hints: KeyHint[] = []) {
-    const identity = this._identityProvider();
+    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
 
     /*
      * 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 feedProvider = this._createFeedProvider(partyKey);
+    const feedProvider = this._feedProviderFactory(partyKey);
     const { feed } = await feedProvider.createOrOpenWritableFeed();
     const feedKeyPair = identity.keyring.getKey(feed.key);
     assert(feedKeyPair, 'Keypair for writable feed not found.');
-    const party = new PartyInternal(
+    const party = new DataParty(
       partyKey,
       this._modelFactory,
       this._snapshotStore,
       feedProvider,
-      this._identityProvider,
+      identity.createCredentialsSigner(),
+      identity.preferences,
       this._networkManager,
-      [{ type: feedKeyPair.type, publicKey: feedKeyPair.publicKey }, ...hints],
+      hints,
       undefined,
       this._options
     );
@@ -156,18 +158,21 @@ export class PartyFactory {
    * @param hints
    */
   async constructParty (partyKey: PartyKey, hints: KeyHint[] = [], initialTimeframe?: Timeframe) {
+    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
+
     // TODO(marik-d): Support read-only parties if this feed doesn't exist?
-    const feedProvider = this._createFeedProvider(partyKey);
+    const feedProvider = this._feedProviderFactory(partyKey);
 
     //
     // Create the party.
     //
-    const party = new PartyInternal(
+    const party = new DataParty(
       partyKey,
       this._modelFactory,
       this._snapshotStore,
       feedProvider,
-      this._identityProvider,
+      identity.createCredentialsSigner(),
+      identity.preferences,
       this._networkManager,
       hints,
       initialTimeframe,
@@ -186,11 +191,11 @@ export class PartyFactory {
     return party;
   }
 
-  async joinParty (invitationDescriptor: InvitationDescriptor, secretProvider: SecretProvider): Promise<PartyInternal> {
+  async joinParty (invitationDescriptor: InvitationDescriptor, secretProvider: SecretProvider): Promise<DataParty> {
     const haloInvitation = !!invitationDescriptor.identityKey;
     const originalInvitation = invitationDescriptor;
 
-    const identity = this._identityProvider();
+    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
     // Claim the offline invitation and convert it into an interactive invitation.
     if (InvitationDescriptorType.OFFLINE === invitationDescriptor.type) {
       const invitationClaimer = new OfflineInvitationClaimer(this._networkManager, invitationDescriptor);
@@ -204,8 +209,13 @@ export class PartyFactory {
     // TODO(burdon): Factor out.
     const initiator = new GreetingInitiator(
       this._networkManager,
-      identity,
-      invitationDescriptor
+      invitationDescriptor,
+      async (partyKey, nonce) => [createDataPartyAdmissionMessages(
+        identity.createCredentialsSigner(),
+        partyKey,
+        identity.identityGenesis ?? raise(new IdentityNotInitializedError()),
+        nonce
+      )]
     );
 
     await initiator.connect();
@@ -230,8 +240,8 @@ export class PartyFactory {
     return party;
   }
 
-  async cloneParty (snapshot: PartySnapshot): Promise<PartyInternal> {
-    const identity = this._identityProvider();
+  async cloneParty (snapshot: PartySnapshot): Promise<DataParty> {
+    const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
 
     assert(!this._options.readOnly, 'PartyFactory is read-only');
     assert(identity.identityGenesis, 'IdentityGenesis must exist');