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

package/src/parties/party-manager.test.ts

@@ -12,13 +12,13 @@ import { it as test } from 'mocha';
 import { latch } from '@dxos/async';
 import {
   createPartyGenesisMessage,
+  defaultSecretProvider,
   Keyring, KeyType,
   SecretProvider,
   SecretValidator
 } from '@dxos/credentials';
 import {
-  createKeyPair, generateSeedPhrase,
-  keyPairFromSeedPhrase, PublicKey,
+  createKeyPair, PublicKey,
   randomBytes,
   sign,
   SIGNATURE_LENGTH, verify
@@ -30,18 +30,17 @@ import { ModelFactory } from '@dxos/model-factory';
 import { NetworkManager } from '@dxos/network-manager';
 import { ObjectModel } from '@dxos/object-model';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
-import { afterTest } from '@dxos/testutils';
+import { afterTest, testTimeout } from '@dxos/testutils';
 
 import { Item } from '../api';
-import { autoPartyOpener, HaloFactory, IdentityManager } from '../halo';
-import { OfflineInvitationClaimer } from '../invitations';
-import { MetadataStore } from '../metadata';
-import { PartyFeedProvider } from '../pipeline';
+import { HaloFactory, Identity, IdentityManager } from '../halo';
+import { defaultInvitationAuthenticator, OfflineInvitationClaimer } from '../invitations';
+import { MetadataStore, PartyFeedProvider } from '../pipeline';
 import { SnapshotStore } from '../snapshots';
 import { messageLogger } from '../testing';
 import { createRamStorage } from '../util';
+import { PARTY_ITEM_TYPE } from './data-party';
 import { PartyFactory } from './party-factory';
-import { PARTY_ITEM_TYPE } from './party-internal';
 import { PartyManager } from './party-manager';
 
 const log = debug('dxos:echo:parties:party-manager:test');
@@ -55,62 +54,53 @@ const log = debug('dxos:echo:parties:party-manager:test');
  * @param open - Open the PartyManager
  * @param createIdentity - Create the identity key record.
  */
-const setup = async (open = true, createIdentity = true) => {
+const setup = async () => {
   const keyring = new Keyring();
   const metadataStore = new MetadataStore(createRamStorage());
   const feedStore = new FeedStore(createStorage('', StorageType.RAM), { valueEncoding: codec });
 
-  let seedPhrase;
-  if (createIdentity) {
-    seedPhrase = generateSeedPhrase();
-    const keyPair = keyPairFromSeedPhrase(seedPhrase);
-    await keyring.addKeyRecord({
-      publicKey: PublicKey.from(keyPair.publicKey),
-      secretKey: keyPair.secretKey,
-      type: KeyType.IDENTITY
-    });
+  const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
 
-    assert(keyring.keys.length === 1);
-  }
+  assert(keyring.keys.length === 1);
 
   const snapshotStore = new SnapshotStore(createStorage('', StorageType.RAM));
   const modelFactory = new ModelFactory().registerModel(ObjectModel);
   const networkManager = new NetworkManager();
   const feedProviderFactory = (partyKey: PublicKey) => new PartyFeedProvider(metadataStore, keyring, feedStore, partyKey);
-  const partyFactory = new PartyFactory(
-    () => identityManager.identity,
+
+  const haloFactory = new HaloFactory(
     networkManager,
     modelFactory,
     snapshotStore,
     feedProviderFactory,
+    keyring,
     {
       writeLogger: messageLogger('<<<'),
       readLogger: messageLogger('>>>')
     }
   );
-
-  const haloFactory: HaloFactory = new HaloFactory(partyFactory, networkManager, keyring);
-  const identityManager = new IdentityManager(keyring, haloFactory, metadataStore);
-  const partyManager = new PartyManager(metadataStore, snapshotStore, () => identityManager.identity, partyFactory);
-  afterTest(() => partyManager.close());
-
-  identityManager.ready.once(() => {
-    assert(identityManager.identity.halo?.isOpen);
-    const unsub = autoPartyOpener(identityManager.identity.preferences!, partyManager);
-    afterTest(unsub);
+  const haloParty = await haloFactory.createHalo({
+    identityDisplayName: identityKey.publicKey.humanize()
   });
+  afterTest(() => haloParty.close());
+  const identity = new Identity(keyring, haloParty);
 
-  if (open) {
-    await partyManager.open();
-    if (createIdentity) {
-      const haloParty = await identityManager.createHalo({
-        identityDisplayName: identityManager.identity.identityKey!.publicKey.humanize()
-      });
-      afterTest(() => haloParty.close());
+  const partyFactory = new PartyFactory(
+    () => identity,
+    networkManager,
+    modelFactory,
+    snapshotStore,
+    feedProviderFactory,
+    {
+      writeLogger: messageLogger('<<<'),
+      readLogger: messageLogger('>>>')
     }
-  }
+  );
+  const partyManager = new PartyManager(metadataStore, snapshotStore, () => identity, partyFactory);
+  await partyManager.open();
+  afterTest(() => partyManager.close());
 
-  return { feedStore, partyManager, identityManager, seedPhrase };
+  return { feedStore, partyManager, identity };
 };
 
 describe('Party manager', () => {
@@ -120,7 +110,7 @@ describe('Party manager', () => {
   });
 
   test('Created locally', async () => {
-    const { partyManager, identityManager } = await setup();
+    const { partyManager, identity } = await setup();
 
     const [update, setUpdated] = latch();
     const unsubscribe = partyManager.update.on((party) => {
@@ -134,10 +124,10 @@ describe('Party manager', () => {
     expect(party.isOpen).toBeTruthy();
 
     // The Party key is an inception key, so its secret should be destroyed immediately after use.
-    const partyKey = identityManager.identity.keyring.getKey(party.key);
+    const partyKey = identity.keyring.getKey(party.key);
     expect(partyKey).toBeDefined();
     assert(partyKey);
-    expect(identityManager.identity.keyring.hasSecretKey(partyKey)).toBe(false);
+    expect(identity.keyring.hasSecretKey(partyKey)).toBe(false);
 
     await update;
   });
@@ -192,8 +182,20 @@ describe('Party manager', () => {
     const snapshotStore = new SnapshotStore(createStorage('', StorageType.RAM));
     const networkManager = new NetworkManager();
     const feedProviderFactory = (partyKey: PublicKey) => new PartyFeedProvider(metadataStore, keyring, feedStore, partyKey);
-    const partyFactory: PartyFactory = new PartyFactory(() => identityManager.identity, networkManager, modelFactory, snapshotStore, feedProviderFactory);
-    const haloFactory = new HaloFactory(partyFactory, networkManager, keyring);
+    const partyFactory = new PartyFactory(
+      () => identityManager.identity,
+      networkManager,
+      modelFactory,
+      snapshotStore,
+      feedProviderFactory
+    );
+    const haloFactory: HaloFactory = new HaloFactory(
+      networkManager,
+      modelFactory,
+      snapshotStore,
+      feedProviderFactory,
+      keyring
+    );
     const identityManager = new IdentityManager(keyring, haloFactory, metadataStore);
     const partyManager = new PartyManager(metadataStore, snapshotStore, () => identityManager.identity, partyFactory);
 
@@ -233,6 +235,8 @@ describe('Party manager', () => {
     }
 
     // Open.
+    await identityManager.createHalo();
+    afterTest(() => identityManager.close());
     await partyManager.open();
     expect(partyManager.parties).toHaveLength(numParties);
     await partyManager.close();
@@ -246,7 +250,7 @@ describe('Party manager', () => {
     const PIN = Buffer.from('0000');
     const secretProvider: SecretProvider = async () => PIN;
     const secretValidator: SecretValidator = async (invitation, secret) => secret.equals(PIN);
-    await partyA.invitationManager.createInvitation({ secretProvider, secretValidator }, { expiration: Date.now() + 3000 });
+    await partyA.invitationManager.createInvitation({ secretProvider, secretValidator }, { expiration: Date.now() + 1000 });
   });
 
   test('Create invitation', async () => {
@@ -278,8 +282,8 @@ describe('Party manager', () => {
   });
 
   test('Join a party - PIN', async () => {
-    const { partyManager: partyManagerA, identityManager: identityManagerA } = await setup();
-    const { partyManager: partyManagerB, identityManager: identityManagerB } = await setup();
+    const { partyManager: partyManagerA, identity: identityA } = await setup();
+    const { partyManager: partyManagerB, identity: identityB } = await setup();
 
     // Create the Party.
     expect(partyManagerA.parties).toHaveLength(0);
@@ -339,13 +343,13 @@ describe('Party manager', () => {
       const members = party.queryMembers().value;
       expect(members.length).toBe(2);
       for (const member of members) {
-        if (identityManagerA.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerA.identity.identityKey!.publicKey.humanize());
-          expect(member.displayName).toEqual(identityManagerA.identity.displayName);
+        if (identityA.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityA.identityKey!.publicKey.humanize());
+          expect(member.displayName).toEqual(identityA.displayName);
         }
-        if (identityManagerB.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerB.identity.identityKey!.publicKey.humanize());
-          expect(member.displayName).toEqual(identityManagerB.identity.displayName);
+        if (identityB.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityB.identityKey!.publicKey.humanize());
+          expect(member.displayName).toEqual(identityB.displayName);
         }
       }
     }
@@ -354,8 +358,8 @@ describe('Party manager', () => {
   });
 
   test('Join a party - signature', async () => {
-    const { partyManager: partyManagerA, identityManager: identityManagerA } = await setup();
-    const { partyManager: partyManagerB, identityManager: identityManagerB } = await setup();
+    const { partyManager: partyManagerA, identity: identityA } = await setup();
+    const { partyManager: partyManagerB, identity: identityB } = await setup();
 
     // This would typically be a keypair associated with BotFactory.
     const keyPair = createKeyPair();
@@ -420,21 +424,19 @@ describe('Party manager', () => {
       const members = party.queryMembers().value;
       expect(members.length).toBe(2);
       for (const member of members) {
-        if (identityManagerA.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerA.identity.identityKey!.publicKey.humanize());
+        if (identityA.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityA.identityKey!.publicKey.humanize());
         }
-        if (identityManagerB.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerB.identity.identityKey!.publicKey.humanize());
+        if (identityB.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityB.identityKey!.publicKey.humanize());
         }
       }
     }
   });
 
   test('Join a party - Offline', async () => {
-    const { partyManager: partyManagerA, identityManager: identityManagerA } = await setup();
-    const { partyManager: partyManagerB, identityManager: identityManagerB } = await setup();
-    assert(identityManagerA.identity.identityKey);
-    assert(identityManagerB.identity.identityKey);
+    const { partyManager: partyManagerA, identity: identityA } = await setup();
+    const { partyManager: partyManagerB, identity: identityB } = await setup();
 
     // Create the Party.
     expect(partyManagerA.parties).toHaveLength(0);
@@ -443,12 +445,12 @@ describe('Party manager', () => {
     log(`Created ${partyA.key.toHex()}`);
 
     const invitationDescriptor = await partyA.invitationManager
-      .createOfflineInvitation(identityManagerB.identity.identityKey.publicKey);
+      .createOfflineInvitation(identityB.identityKey!.publicKey);
 
     // Redeem the invitation on B.
     expect(partyManagerB.parties).toHaveLength(0);
     const partyB = await partyManagerB.joinParty(invitationDescriptor,
-      OfflineInvitationClaimer.createSecretProvider(identityManagerB.identity));
+      OfflineInvitationClaimer.createSecretProvider(identityB));
     expect(partyB).toBeDefined();
     log(`Joined ${partyB.key.toHex()}`);
 
@@ -479,18 +481,42 @@ describe('Party manager', () => {
       const members = party.queryMembers().value;
       expect(members.length).toBe(2);
       for (const member of members) {
-        if (identityManagerA.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerA.identity.identityKey!.publicKey.humanize());
-          expect(member.displayName).toEqual(identityManagerA.identity.displayName);
+        if (identityA.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityA.identityKey!.publicKey.humanize());
+          expect(member.displayName).toEqual(identityA.displayName);
         }
-        if (identityManagerB.identity.identityKey!.publicKey.equals(member.publicKey)) {
-          expect(member.displayName).toEqual(identityManagerB.identity.identityKey!.publicKey.humanize());
-          expect(member.displayName).toEqual(identityManagerB.identity.displayName);
+        if (identityB.identityKey!.publicKey.equals(member.publicKey)) {
+          expect(member.displayName).toEqual(identityB.identityKey!.publicKey.humanize());
+          expect(member.displayName).toEqual(identityB.displayName);
         }
       }
     }
   }).timeout(10_000);
 
+  test('3 peers in a party', async () => {
+    const { partyManager: partyManagerA } = await setup();
+    const { partyManager: partyManagerB } = await setup();
+    const { partyManager: partyManagerC } = await setup();
+
+    const partyA = await partyManagerA.createParty();
+
+    const invitationA = await partyA.invitationManager.createInvitation(defaultInvitationAuthenticator);
+    const partyB = await partyManagerB.joinParty(invitationA, defaultSecretProvider);
+
+    const invitationB = await partyB.invitationManager.createInvitation(defaultInvitationAuthenticator);
+    const partyC = await partyManagerC.joinParty(invitationB, defaultSecretProvider);
+
+    await partyA.database.createItem({ type: 'test:item-a' });
+    await partyB.database.createItem({ type: 'test:item-b' });
+    await partyC.database.createItem({ type: 'test:item-c' });
+
+    for (const party of [partyA, partyB, partyC]) {
+      await testTimeout(party.database.waitForItem({ type: 'test:item-a' }));
+      await testTimeout(party.database.waitForItem({ type: 'test:item-b' }));
+      await testTimeout(party.database.waitForItem({ type: 'test:item-c' }));
+    }
+  });
+
   test('Clone party', async () => {
     const { partyManager } = await setup();
 

package/src/parties/party-manager.ts

@@ -15,10 +15,10 @@ import { ComplexMap, boolGuard } from '@dxos/util';
 
 import { IdentityProvider } from '../halo';
 import { InvitationDescriptor } from '../invitations';
-import { MetadataStore } from '../metadata';
+import { MetadataStore } from '../pipeline';
 import { SnapshotStore } from '../snapshots';
+import { DataParty, PARTY_ITEM_TYPE, PARTY_TITLE_PROPERTY } from './data-party';
 import { PartyFactory } from './party-factory';
-import { PartyInternal, PARTY_ITEM_TYPE, PARTY_TITLE_PROPERTY } from './party-internal';
 
 export const CONTACT_DEBOUNCE_INTERVAL = 500;
 
@@ -33,14 +33,14 @@ export interface OpenProgress {
 /**
  * Top-level class manages the complete life-cycle of parties.
  *
- * `PartyManager` => `PartyManager` => `PartyInternal` => `PartyCore`
+ * `ECHO` => `PartyManager` => `DataParty` => `PartyCore`
  */
 export class PartyManager {
   // External event listener.
-  readonly update = new Event<PartyInternal>();
+  readonly update = new Event<DataParty>();
 
   // Map of parties by party key.
-  private readonly _parties = new ComplexMap<PublicKey, PartyInternal>(key => key.toHex());
+  private readonly _parties = new ComplexMap<PublicKey, DataParty>(key => key.toHex());
 
   // Unsubscribe handlers.
   // TODO(burdon): Never used.
@@ -59,7 +59,7 @@ export class PartyManager {
     return this._open;
   }
 
-  get parties (): PartyInternal[] {
+  get parties (): DataParty[] {
     return Array.from(this._parties.values());
   }
 
@@ -77,7 +77,7 @@ export class PartyManager {
     const identity = this._identityProvider();
 
     // TODO(telackey): Does it make any sense to load other parties if we don't have an HALO?
-    if (identity.identityKey) {
+    if (identity?.identityKey) {
       partyKeys = partyKeys.filter(partyKey => !partyKey.equals(identity.identityKey!.publicKey));
     }
 
@@ -97,7 +97,7 @@ export class PartyManager {
           ? await this._partyFactory.constructPartyFromSnapshot(snapshot)
           : await this._partyFactory.constructParty(partyKey);
 
-        const isActive = identity.preferences?.isPartyActive(partyKey) ?? true;
+        const isActive = identity?.preferences?.isPartyActive(partyKey) ?? true;
         if (isActive) {
           await party.open();
           // TODO(marik-d): Might not be required if separately snapshot this item.
@@ -141,7 +141,7 @@ export class PartyManager {
    * Creates a new party, writing its genesis block to the stream.
    */
   @synchronized
-  async createParty (): Promise<PartyInternal> {
+  async createParty (): Promise<DataParty> {
     assert(this._open, 'PartyManager is not open.');
 
     const party = await this._partyFactory.createParty();
@@ -224,7 +224,7 @@ export class PartyManager {
     return party;
   }
 
-  private _setParty (party: PartyInternal) {
+  private _setParty (party: DataParty) {
     const updateContact = async () => {
       try {
         await this._updateContactList(party);
@@ -258,7 +258,7 @@ export class PartyManager {
   }
 
   // TODO(burdon): Refactor.
-  private async _updatePartyTitle (party: PartyInternal) {
+  private async _updatePartyTitle (party: DataParty) {
     if (!this._open) {
       return;
     }
@@ -266,14 +266,14 @@ export class PartyManager {
     const identity = this._identityProvider();
     const item = await party.getPropertiesItem();
     const currentTitle = item.model.get(PARTY_TITLE_PROPERTY);
-    const storedTitle = identity.preferences?.getGlobalPartyPreference(party.key, PARTY_TITLE_PROPERTY);
+    const storedTitle = identity?.preferences?.getGlobalPartyPreference(party.key, PARTY_TITLE_PROPERTY);
     if (storedTitle !== currentTitle) {
-      await identity.preferences?.setGlobalPartyPreference(party, PARTY_TITLE_PROPERTY, currentTitle);
+      await identity?.preferences?.setGlobalPartyPreference(party, PARTY_TITLE_PROPERTY, currentTitle);
     }
   }
 
   // TODO(burdon): Reconcile with `Halo.ContactManager`.
-  private async _updateContactList (party: PartyInternal) {
+  private async _updateContactList (party: DataParty) {
     // Prevent any updates after we closed ECHO.
     // This will get re-run next time echo is loaded so we don't loose any data.
     if (!this._open) {
@@ -282,7 +282,7 @@ export class PartyManager {
 
     const identity = this._identityProvider();
 
-    const contactListItem = identity.contacts?.getContactListItem();
+    const contactListItem = identity?.contacts?.getContactListItem();
     if (!contactListItem) {
       return;
     }
@@ -314,11 +314,11 @@ export class PartyManager {
   }
 
   @timed(5_000)
-  private async _recordPartyJoining (party: PartyInternal) {
+  private async _recordPartyJoining (party: DataParty) {
     const identity = this._identityProvider();
 
     // TODO(marik-d): Extract HALO functionality from this class.
-    if (!identity.preferences) {
+    if (!identity?.preferences) {
       return;
     }
 

package/src/{halo → parties}/party-preferences.ts

@@ -4,8 +4,8 @@
 
 import assert from 'assert';
 
-import { PARTY_TITLE_PROPERTY, PartyInternal } from '../parties';
-import { Preferences } from './preferences';
+import { PARTY_TITLE_PROPERTY, DataParty } from '.';
+import { Preferences } from '../halo/preferences';
 
 export interface ActivationOptions {
   global?: boolean;
@@ -21,7 +21,7 @@ export interface ActivationOptions {
 export class PartyPreferences {
   constructor (
     private readonly _preferences: Preferences,
-    private readonly _party: PartyInternal
+    private readonly _party: DataParty
   ) {
     assert(this._party);
   }

package/src/pipeline/index.ts

@@ -5,5 +5,7 @@
 export * from './message-selector';
 export * from './party-feed-provider';
 export * from './party-processor';
-export * from './party-protocol-factory';
+export * from '../protocol/party-protocol-factory';
 export * from './pipeline';
+export * from './party-core';
+export * from './metadata-store';

package/src/{parties → pipeline}/party-core.test.ts

@@ -16,8 +16,7 @@ import { ObjectModel } from '@dxos/object-model';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { afterTest } from '@dxos/testutils';
 
-import { MetadataStore } from '../metadata';
-import { PartyFeedProvider, ReplicatorProtocolPluginFactory } from '../pipeline';
+import { MetadataStore, PartyFeedProvider, ReplicatorProtocolPluginFactory } from '../pipeline';
 import { SnapshotStore } from '../snapshots';
 import { createRamStorage } from '../util';
 import { PartyCore } from './party-core';

package/src/{parties → pipeline}/party-core.ts

@@ -5,7 +5,7 @@
 import assert from 'assert';
 
 import { synchronized } from '@dxos/async';
-import { KeyHint } from '@dxos/credentials';
+import { KeyHint, KeyType } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { timed } from '@dxos/debug';
 import { createFeedWriter, DatabaseSnapshot, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
@@ -58,7 +58,7 @@ export class PartyCore {
     private readonly _memberKey: PublicKey,
     private readonly _initialTimeframe?: Timeframe,
     private readonly _options: PartyOptions = {}
-  ) {}
+  ) { }
 
   get key (): PartyKey {
     return this._partyKey;
@@ -111,14 +111,23 @@ export class PartyCore {
 
     this._timeframeClock = new TimeframeClock(this._initialTimeframe);
 
+    // Open all feeds known from metadata and open or create a writable feed to the party.
+    await this._feedProvider.openKnownFeeds();
+    const writableFeed = await this._feedProvider.createOrOpenWritableFeed();
+
     if (!this._partyProcessor) {
       this._partyProcessor = new PartyProcessor(this._partyKey);
     }
+
     // Automatically open new admitted feeds.
     this._subscriptions.push(this._partyProcessor.feedAdded.on(feed => {
       void this._feedProvider.createOrOpenReadOnlyFeed(feed);
     }));
 
+    // Hint at our own writable feed.
+    // TODO(dmaretskyi): Does not seem like it should be required, but without it replication between devices (B -> A) breaks.
+    await this._partyProcessor.takeHints([{ type: KeyType.FEED, publicKey: writableFeed.key }]);
+
     if (keyHints.length > 0) {
       await this._partyProcessor.takeHints(keyHints);
     }
@@ -127,17 +136,13 @@ export class PartyCore {
     // Pipeline
     //
 
-    await this._feedProvider.openKnownFeeds();
     const iterator = await this._feedProvider.createIterator(
       createMessageSelector(this._partyProcessor, this._timeframeClock),
       this._initialTimeframe
     );
 
-    const { feed } = await this._feedProvider.createOrOpenWritableFeed();
-    const feedWriteStream = createFeedWriter(feed);
-
     this._pipeline = new Pipeline(
-      this._partyProcessor, iterator, this._timeframeClock, feedWriteStream, this._options);
+      this._partyProcessor, iterator, this._timeframeClock, createFeedWriter(writableFeed.feed), this._options);
 
     // TODO(burdon): Support read-only parties.
     const [readStream, writeStream] = await this._pipeline.open();

package/src/pipeline/party-feed-provider.ts

@@ -5,16 +5,17 @@
 import assert from 'assert';
 import debug from 'debug';
 
-import { Event } from '@dxos/async';
+import { Event, synchronized } from '@dxos/async';
 import { Keyring, KeyType } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { FeedStoreIterator, MessageSelector, Timeframe } from '@dxos/echo-protocol';
 import { FeedDescriptor, FeedStore } from '@dxos/feed-store';
 import { ComplexMap } from '@dxos/util';
 
-import { MetadataStore } from '../metadata';
+import { MetadataStore } from './metadata-store';
 
 const STALL_TIMEOUT = 1000;
+const log = debug('dxos:echo-db:party-feed-provider');
 const warn = debug('dxos:echo-db:party-feed-provider:warn');
 
 export class PartyFeedProvider {
@@ -32,6 +33,20 @@ export class PartyFeedProvider {
     return Array.from(this._feeds.values());
   }
 
+  @synchronized
+  async openKnownFeeds () {
+    for (const feedKey of this._metadataStore.getParty(this._partyKey)?.feedKeys ?? []) {
+      if (!this._feeds.has(feedKey)) {
+        const fullKey = this._keyring.getFullKey(feedKey);
+        const feed = fullKey?.secretKey
+          ? await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey)
+          : await this._feedStore.openReadOnlyFeed(feedKey);
+        this._trackFeed(feed);
+      }
+    }
+  }
+
+  @synchronized
   async createOrOpenWritableFeed () {
     const partyMetadata = this._metadataStore.getParty(this._partyKey);
     if (!partyMetadata?.dataFeedKey) {
@@ -48,24 +63,11 @@ export class PartyFeedProvider {
     }
 
     const feed = await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey);
-    this._feeds.set(fullKey.publicKey, feed);
-    this.feedOpened.emit(feed);
+    this._trackFeed(feed);
     return feed;
   }
 
-  async openKnownFeeds () {
-    for (const feedKey of this._metadataStore.getParty(this._partyKey)?.feedKeys ?? []) {
-      if (!this._feeds.has(feedKey)) {
-        const fullKey = this._keyring.getFullKey(feedKey);
-        const feed = fullKey?.secretKey
-          ? await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey)
-          : await this._feedStore.openReadOnlyFeed(feedKey);
-        this._feeds.set(feedKey, feed);
-        this.feedOpened.emit(feed);
-      }
-    }
-  }
-
+  @synchronized
   async createOrOpenReadOnlyFeed (feedKey: PublicKey): Promise<FeedDescriptor> {
     if (this._feeds.has(feedKey)) {
       return this._feeds.get(feedKey)!;
@@ -76,19 +78,28 @@ export class PartyFeedProvider {
       await this._keyring.addPublicKey({ type: KeyType.FEED, publicKey: feedKey });
     }
     const feed = await this._feedStore.openReadOnlyFeed(feedKey);
-    this._feeds.set(feedKey, feed);
-    this.feedOpened.emit(feed);
+    this._trackFeed(feed);
     return feed;
   }
 
+  private _trackFeed (feed: FeedDescriptor) {
+    assert(!this._feeds.has(feed.key));
+    this._feeds.set(feed.key, feed);
+    this.feedOpened.emit(feed);
+
+    log(`Party feed set changed: ${JSON.stringify({
+      party: this._partyKey,
+      feeds: Array.from(this._feeds.values()).map(feed => feed.key)
+    })}`);
+  }
+
   private async _createReadWriteFeed () {
     const feedKey = await this._keyring.createKeyRecord({ type: KeyType.FEED });
     const fullKey = this._keyring.getFullKey(feedKey.publicKey);
     assert(fullKey && fullKey.secretKey);
     await this._metadataStore.setDataFeed(this._partyKey, fullKey.publicKey);
     const feed = await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey);
-    this._feeds.set(fullKey.publicKey, feed);
-    this.feedOpened.emit(feed);
+    this._trackFeed(feed);
     return feed;
   }
 

package/src/protocol/auth-plugin.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Authenticator, AuthPlugin } from '@dxos/credentials';
+import { PublicKey } from '@dxos/crypto';
+import { Replicator } from '@dxos/protocol-plugin-replicator';
+
+/**
+ * Creates authenticator network-protocol plugin that guards access to the replicator.
+ */
+export function createAuthPlugin (authenticator: Authenticator, peerId: PublicKey) {
+  return new AuthPlugin(peerId.asBuffer(), authenticator, [Replicator.extension]);
+}