@dxos/echo-db 2.33.3-dev.5c4af82a → 2.33.3-dev.63b42961

package/src/halo/identity.ts

@@ -9,6 +9,7 @@ import { Filter, KeyChain, KeyRecord, Keyring, KeyType, SignedMessage, Signer }
 import { failUndefined } from '@dxos/debug';
 
 import { CredentialsSigner } from '../protocol/credentials-signer';
+import { IdentityCredentials } from '../protocol/identity-credentials';
 import { ContactManager } from './contact-manager';
 import { HaloParty } from './halo-party';
 import { Preferences } from './preferences';
@@ -20,7 +21,7 @@ const log = debug('dxos:echo-db:identity');
  *
  * Acts as a read-only view into IdentityManager.
  */
-export class Identity {
+export class Identity implements IdentityCredentials {
   private readonly _identityKey: KeyRecord;
   private readonly _deviceKey: KeyRecord;
   private readonly _deviceKeyChain: KeyChain;
@@ -42,6 +43,10 @@ export class Identity {
     return this._keyring;
   }
 
+  get keyring (): Keyring {
+    return this._keyring;
+  }
+
   get identityKey (): KeyRecord {
     return this._identityKey;
   }
@@ -54,14 +59,6 @@ export class Identity {
     return this._deviceKeyChain;
   }
 
-  get preferences (): Preferences {
-    return this._halo.preferences;
-  }
-
-  get contacts (): ContactManager {
-    return this._halo.contacts;
-  }
-
   get displayName (): string | undefined {
     return this.identityInfo?.signed.payload.displayName;
   }
@@ -78,6 +75,14 @@ export class Identity {
     return this._halo.identityGenesis ?? failUndefined();
   }
 
+  get preferences (): Preferences {
+    return this._halo.preferences;
+  }
+
+  get contacts (): ContactManager {
+    return this._halo.contacts;
+  }
+
   /**
    * HALO party. Must be open.
    */
@@ -85,10 +90,6 @@ export class Identity {
     return this._halo;
   }
 
-  get keyring () {
-    return this._keyring;
-  }
-
   createCredentialsSigner (): CredentialsSigner {
     return new CredentialsSigner(
       this._keyring,

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

@@ -24,7 +24,7 @@ import { keyToBuffer, keyToString, PublicKey, randomBytes } from '@dxos/crypto';
 import { FullyConnectedTopology, NetworkManager } from '@dxos/network-manager';
 
 import { InvalidInvitationError } from '../errors';
-import { Identity } from '../halo';
+import { CredentialsSigner } from '../protocol';
 import { greetingProtocolProvider } from './greeting-protocol-provider';
 import { GreetingState } from './greeting-responder';
 import { InvitationDescriptor, InvitationDescriptorType } from './invitation-descriptor';
@@ -169,17 +169,17 @@ export class OfflineInvitationClaimer {
   }
 
   // The secretProvider should provide an `Auth` message signed directly by the Identity key.
-  static createSecretProvider (identity: Identity): SecretProvider {
+  static createSecretProvider (credentials: CredentialsSigner): SecretProvider {
     return async (info?: SecretInfo) => {
       return Buffer.from(codec.encode(
         /* The signed portion of the Auth message includes the ID and authNonce provided
          * by the `info` object. These values will be validated on the other end.
          */
         createAuthMessage(
-          identity.signer,
+          credentials.signer,
           info!.id.value,
-          identity.identityKey,
-          identity.deviceKeyChain,
+          credentials.getIdentityKey(),
+          credentials.getDeviceSigningKeys(),
           undefined,
           info!.authNonce.value)
       ));

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

@@ -0,0 +1,212 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import expect from 'expect';
+import { it as test } from 'mocha';
+
+import { createKeyAdmitMessage, createPartyGenesisMessage, defaultSecretProvider, KeyHint, Keyring, KeyType, codec as haloCodec } from '@dxos/credentials';
+import { 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 { createStorage, StorageType } from '@dxos/random-access-multi-storage';
+
+import { createDataPartyAdmissionMessages, defaultInvitationAuthenticator, GreetingInitiator } from '../invitations';
+import { MetadataStore, PartyFeedProvider } from '../pipeline';
+import { createAuthenticator, createCredentialsProvider } from '../protocol';
+import { createTestIdentityCredentials, deriveTestDeviceCredentials, IdentityCredentials } from '../protocol/identity-credentials';
+import { SnapshotStore } from '../snapshots';
+import { createRamStorage } from '../util';
+import { DataParty } from './data-party';
+
+describe('DataParty', () => {
+  const createParty = async (identity: IdentityCredentials, partyKey: PublicKey, hints: KeyHint[]) => {
+    const metadataStore = new MetadataStore(createRamStorage());
+    const feedStore = new FeedStore(createStorage('', StorageType.RAM), { valueEncoding: codec });
+    const snapshotStore = new SnapshotStore(createStorage('', StorageType.RAM));
+    const modelFactory = new ModelFactory().registerModel(ObjectModel);
+    const networkManager = new NetworkManager();
+    const partyFeedProvider = new PartyFeedProvider(metadataStore, identity.keyring, feedStore, partyKey);
+
+    return new DataParty(
+      partyKey,
+      modelFactory,
+      snapshotStore,
+      partyFeedProvider,
+      identity.createCredentialsSigner(),
+      identity.preferences,
+      networkManager,
+      hints
+    );
+  };
+
+  test('open & close', async () => {
+    const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+    const party = await createParty(identity, partyKey.publicKey, []);
+
+    await party.open();
+    await party.close();
+  });
+
+  test('edit data', async () => {
+    const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+    const party = await createParty(identity, partyKey.publicKey, []);
+    await party.open();
+
+    const feed = await party.feedProvider.createOrOpenWritableFeed();
+    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+      keyring,
+      partyKey,
+      feed.key,
+      partyKey
+    ));
+
+    await party.database.createItem({ type: 'test:item' });
+
+    await party.close();
+  });
+
+  test('authenticates its own credentials', async () => {
+    const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+
+    const party = await createParty(identity, partyKey.publicKey, []);
+    await party.open();
+    const feed = await party.feedProvider.createOrOpenWritableFeed();
+    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+      keyring,
+      partyKey,
+      feed.key,
+      partyKey
+    ));
+
+    const authenticator = createAuthenticator(party.processor, identity.createCredentialsSigner());
+    const credentialsProvider = createCredentialsProvider(identity.createCredentialsSigner(), party.key, feed.key);
+
+    const wrappedCredentials = haloCodec.decode(credentialsProvider.get());
+    expect(await authenticator.authenticate(wrappedCredentials.payload)).toEqual(true);
+
+    await party.close();
+  });
+
+  test('authenticates another device', async () => {
+    const keyring = new Keyring();
+    const identityA = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+
+    const party = await createParty(identityA, partyKey.publicKey, []);
+    await party.open();
+    const feed = await party.feedProvider.createOrOpenWritableFeed();
+    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+      keyring,
+      partyKey,
+      feed.key,
+      partyKey
+    ));
+    const authenticator = createAuthenticator(party.processor, identityA.createCredentialsSigner());
+
+    const identityB = await deriveTestDeviceCredentials(identityA);
+    const credentialsProvider = createCredentialsProvider(identityB.createCredentialsSigner(), party.key, feed.key);
+
+    const wrappedCredentials = haloCodec.decode(credentialsProvider.get());
+    expect(await authenticator.authenticate(wrappedCredentials.payload)).toEqual(true);
+
+    await party.close();
+  });
+
+  test('two instances replicating', async () => {
+    const keyring = new Keyring();
+    const identityA = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+
+    const partyA = await createParty(identityA, partyKey.publicKey, []);
+    await partyA.open();
+    const feedA = await partyA.feedProvider.createOrOpenWritableFeed();
+    await partyA.processor.writeHaloMessage(createPartyGenesisMessage(
+      keyring,
+      partyKey,
+      feedA.key,
+      partyKey
+    ));
+    await partyA.processor.writeHaloMessage(createKeyAdmitMessage(
+      keyring,
+      partyKey.publicKey,
+      identityA.identityKey,
+      [partyKey]
+    ));
+
+    const identityB = await deriveTestDeviceCredentials(identityA);
+    const partyB = await createParty(identityB, partyKey.publicKey, [
+      { type: KeyType.FEED, publicKey: feedA.key }
+    ]);
+    await partyB.open();
+
+    await partyA.database.createItem({ type: 'test:item-a' });
+    await partyB.database.waitForItem({ type: 'test:item-a' });
+
+    await partyB.database.createItem({ type: 'test:item-b' });
+    await partyA.database.waitForItem({ type: 'test:item-b' });
+
+    await partyA.close();
+    await partyB.close();
+  });
+
+  test('invitations', async () => {
+    const identityA = await createTestIdentityCredentials(new Keyring());
+    const partyKeyA = await identityA.keyring.createKeyRecord({ type: KeyType.PARTY });
+
+    const partyA = await createParty(identityA, partyKeyA.publicKey, []);
+    await partyA.open();
+    const feedA = await partyA.feedProvider.createOrOpenWritableFeed();
+    await partyA.processor.writeHaloMessage(createPartyGenesisMessage(
+      identityA.keyring,
+      partyKeyA,
+      feedA.key,
+      partyKeyA
+    ));
+    await partyA.processor.writeHaloMessage(createKeyAdmitMessage(
+      identityA.keyring,
+      partyKeyA.publicKey,
+      identityA.identityKey,
+      [partyKeyA]
+    ));
+
+    const invitation = await partyA.invitationManager.createInvitation(defaultInvitationAuthenticator);
+
+    const identityB = await createTestIdentityCredentials(new Keyring());
+    const initiator = new GreetingInitiator(
+      new NetworkManager(),
+      invitation,
+      async (partyKey, nonce) => [createDataPartyAdmissionMessages(
+        identityB.createCredentialsSigner(),
+        partyKey,
+        identityB.identityGenesis,
+        nonce
+      )]
+    );
+
+    await initiator.connect();
+    const { partyKey: partyKeyB, hints: hintsB } = await initiator.redeemInvitation(defaultSecretProvider);
+    expect(partyKeyB.equals(partyKeyA.publicKey));
+    const partyB = await createParty(identityB, partyKeyB, hintsB);
+    await partyB.open();
+    await initiator.destroy();
+
+    await partyA.database.createItem({ type: 'test:item-a' });
+    await partyB.database.waitForItem({ type: 'test:item-a' });
+
+    await partyB.database.createItem({ type: 'test:item-b' });
+    await partyA.database.waitForItem({ type: 'test:item-b' });
+
+    await partyA.close();
+    await partyB.close();
+  });
+});

package/src/parties/data-party.ts

@@ -175,8 +175,7 @@ export class DataParty {
       this._networkManager,
       this._feedProvider,
       deviceKey.publicKey,
-      createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key),
-      this._partyCore.processor.getActiveFeedSet()
+      createCredentialsProvider(this._credentialsSigner, this._partyCore.key, writeFeed.key)
     );
 
     await this._protocol.start([

package/src/parties/party-factory.ts

@@ -22,12 +22,12 @@ 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, PartyOptions } from '../pipeline';
+import { IdentityCredentialsProvider } from '../protocol/identity-credentials';
 import { SnapshotStore } from '../snapshots';
 import { DataParty, PARTY_ITEM_TYPE } from './data-party';
 
@@ -38,7 +38,7 @@ const log = debug('dxos:echo-db:party-factory');
  */
 export class PartyFactory {
   constructor (
-    private readonly _identityProvider: IdentityProvider,
+    private readonly _identityProvider: IdentityCredentialsProvider,
     private readonly _networkManager: NetworkManager,
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
@@ -64,7 +64,7 @@ export class PartyFactory {
 
     // PartyGenesis (self-signed by Party).
     await party.processor.writeHaloMessage(createPartyGenesisMessage(
-      identity.signer,
+      identity.keyring,
       partyKey,
       writableFeed.key,
       partyKey)
@@ -72,15 +72,16 @@ export class PartyFactory {
 
     // KeyAdmit (IdentityGenesis in an Envelope signed by Party).
     await party.processor.writeHaloMessage(createEnvelopeMessage(
-      identity.signer,
+      identity.keyring,
       partyKey.publicKey,
       wrapMessage(identity.identityGenesis),
       [partyKey])
     );
 
     // FeedAdmit (signed by the Device KeyChain).
+    // TODO(dmaretskyi): Is this really needed since a feed is already admitted by party genesis message.
     await party.processor.writeHaloMessage(createFeedAdmitMessage(
-      identity.signer,
+      identity.keyring,
       partyKey.publicKey,
       writableFeed.key,
       [identity.deviceKeyChain]
@@ -89,7 +90,7 @@ export class PartyFactory {
     // IdentityInfo in an Envelope signed by the Device KeyChain.
     if (identity.identityInfo) {
       await party.processor.writeHaloMessage(createEnvelopeMessage(
-        identity.signer,
+        identity.keyring,
         partyKey.publicKey,
         wrapMessage(identity.identityInfo),
         [identity.deviceKeyChain]
@@ -141,7 +142,7 @@ export class PartyFactory {
     assert(signingKey, 'No device key or keychain.');
     // Write the Feed genesis message.
     await party.processor.writeHaloMessage(createFeedAdmitMessage(
-      identity.signer,
+      identity.keyring,
       partyKey,
       feedKeyPair.publicKey,
       [signingKey]
@@ -224,7 +225,7 @@ export class PartyFactory {
       const infoMessage = identity.identityInfo;
       if (infoMessage) {
         await party.processor.writeHaloMessage(createEnvelopeMessage(
-          identity.signer,
+          identity.keyring,
           partyKey,
           wrapMessage(infoMessage),
           [identity.deviceKeyChain]
@@ -250,7 +251,7 @@ export class PartyFactory {
 
     // PartyGenesis (self-signed by Party).
     await party.processor.writeHaloMessage(createPartyGenesisMessage(
-      identity.signer,
+      identity.keyring,
       partyKey,
       writableFeed.key,
       partyKey)
@@ -258,7 +259,7 @@ export class PartyFactory {
 
     // KeyAdmit (IdentityGenesis in an Envelope signed by Party).
     await party.processor.writeHaloMessage(createEnvelopeMessage(
-      identity.signer,
+      identity.keyring,
       partyKey.publicKey,
       wrapMessage(identity.identityGenesis),
       [partyKey]
@@ -266,7 +267,7 @@ export class PartyFactory {
 
     // FeedAdmit (signed by the Device KeyChain).
     await party.processor.writeHaloMessage(createFeedAdmitMessage(
-      identity.signer,
+      identity.keyring,
       partyKey.publicKey,
       writableFeed.key,
       [identity.deviceKeyChain]
@@ -275,7 +276,7 @@ export class PartyFactory {
     // IdentityInfo in an Envelope signed by the Device KeyChain.
     if (identity.identityInfo) {
       await party.processor.writeHaloMessage(createEnvelopeMessage(
-        identity.signer,
+        identity.keyring,
         partyKey.publicKey,
         wrapMessage(identity.identityInfo),
         [identity.deviceKeyChain]

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

@@ -33,9 +33,9 @@ import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { afterTest, testTimeout } from '@dxos/testutils';
 
 import { Item } from '../api';
-import { HaloFactory, Identity, IdentityManager } from '../halo';
 import { defaultInvitationAuthenticator, OfflineInvitationClaimer } from '../invitations';
 import { MetadataStore, PartyFeedProvider } from '../pipeline';
+import { createTestIdentityCredentials } from '../protocol/identity-credentials';
 import { SnapshotStore } from '../snapshots';
 import { messageLogger } from '../testing';
 import { createRamStorage } from '../util';
@@ -58,33 +58,12 @@ const setup = async () => {
   const keyring = new Keyring();
   const metadataStore = new MetadataStore(createRamStorage());
   const feedStore = new FeedStore(createStorage('', StorageType.RAM), { valueEncoding: codec });
-
-  const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
-
-  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 haloFactory = new HaloFactory(
-    networkManager,
-    modelFactory,
-    snapshotStore,
-    feedProviderFactory,
-    keyring,
-    {
-      writeLogger: messageLogger('<<<'),
-      readLogger: messageLogger('>>>')
-    }
-  );
-  const haloParty = await haloFactory.createHalo({
-    identityDisplayName: identityKey.publicKey.humanize()
-  });
-  afterTest(() => haloParty.close());
-  const identity = new Identity(keyring, haloParty);
-
+  const identity = await createTestIdentityCredentials(keyring);
   const partyFactory = new PartyFactory(
     () => identity,
     networkManager,
@@ -171,33 +150,22 @@ describe('Party manager', () => {
   test('Create from cold start', async () => {
     const storage = createStorage('', StorageType.RAM);
     const feedStore = new FeedStore(storage, { valueEncoding: codec });
-
     const keyring = new Keyring();
     const metadataStore = new MetadataStore(createRamStorage());
-
-    const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
-    await keyring.createKeyRecord({ type: KeyType.DEVICE });
-
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
     const snapshotStore = new SnapshotStore(createStorage('', StorageType.RAM));
     const networkManager = new NetworkManager();
     const feedProviderFactory = (partyKey: PublicKey) => new PartyFeedProvider(metadataStore, keyring, feedStore, partyKey);
+
+    const identity = await createTestIdentityCredentials(keyring);
     const partyFactory = new PartyFactory(
-      () => identityManager.identity,
+      () => 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);
+    const partyManager = new PartyManager(metadataStore, snapshotStore, () => identity, partyFactory);
 
     /* TODO(telackey): Injecting "raw" Parties into the feeds behind the scenes seems fishy to me, as it writes the
      * Party messages in a slightly different way than the code inside PartyFactory does, and so could easily diverge
@@ -221,7 +189,7 @@ describe('Party manager', () => {
       assert(feedKey);
 
       const feedStream = createWritableFeedStream(feed);
-      feedStream.write({ halo: createPartyGenesisMessage(keyring, partyKey, feedKey.publicKey, identityKey) });
+      feedStream.write({ halo: createPartyGenesisMessage(keyring, partyKey, feedKey.publicKey, identity.identityKey) });
       feedStream.write({
         echo: checkType<EchoEnvelope>({
           itemId: 'foo',
@@ -235,8 +203,6 @@ describe('Party manager', () => {
     }
 
     // Open.
-    await identityManager.createHalo();
-    afterTest(() => identityManager.close());
     await partyManager.open();
     expect(partyManager.parties).toHaveLength(numParties);
     await partyManager.close();
@@ -450,7 +416,7 @@ describe('Party manager', () => {
     // Redeem the invitation on B.
     expect(partyManagerB.parties).toHaveLength(0);
     const partyB = await partyManagerB.joinParty(invitationDescriptor,
-      OfflineInvitationClaimer.createSecretProvider(identityB));
+      OfflineInvitationClaimer.createSecretProvider(identityB.createCredentialsSigner()));
     expect(partyB).toBeDefined();
     log(`Joined ${partyB.key.toHex()}`);
 

package/src/parties/party-manager.ts

@@ -13,9 +13,9 @@ import { timed } from '@dxos/debug';
 import { PartyKey, PartySnapshot } from '@dxos/echo-protocol';
 import { ComplexMap, boolGuard } from '@dxos/util';
 
-import { IdentityProvider } from '../halo';
 import { InvitationDescriptor } from '../invitations';
 import { MetadataStore } from '../pipeline';
+import { IdentityCredentialsProvider } from '../protocol/identity-credentials';
 import { SnapshotStore } from '../snapshots';
 import { DataParty, PARTY_ITEM_TYPE, PARTY_TITLE_PROPERTY } from './data-party';
 import { PartyFactory } from './party-factory';
@@ -51,7 +51,7 @@ export class PartyManager {
   constructor (
     private readonly _metadataStore: MetadataStore,
     private readonly _snapshotStore: SnapshotStore,
-    private readonly _identityProvider: IdentityProvider,
+    private readonly _identityProvider: IdentityCredentialsProvider,
     private readonly _partyFactory: PartyFactory
   ) {}
 

package/src/pipeline/metadata-store.ts

@@ -4,7 +4,6 @@
 
 import assert from 'assert';
 import debug from 'debug';
-import pify from 'pify';
 
 import { PublicKey } from '@dxos/crypto';
 import { failUndefined } from '@dxos/debug';
@@ -50,12 +49,12 @@ export class MetadataStore {
   async load (): Promise<void> {
     const file = this._storage.createOrOpen('EchoMetadata');
     try {
-      const { size } = await pify(file.stat.bind(file))();
+      const { size } = await file.stat();
       if (size === 0) {
         return;
       }
 
-      const data = await pify(file.read.bind(file))(0, size);
+      const data = await file.read(0, size);
       this._metadata = schema.getCodecForType('dxos.echo.metadata.EchoMetadata').decode(data);
     } catch (err: any) {
       if (err.code === 'ENOENT') {
@@ -64,7 +63,7 @@ export class MetadataStore {
         throw err;
       }
     } finally {
-      await pify(file.close.bind(file))();
+      await file.close();
     }
   }
 
@@ -80,9 +79,9 @@ export class MetadataStore {
 
     try {
       const encoded = Buffer.from(schema.getCodecForType('dxos.echo.metadata.EchoMetadata').encode(data));
-      await pify(file.write.bind(file))(0, encoded);
+      await file.write(0, encoded);
     } finally {
-      await pify(file.close.bind(file))();
+      await file.close();
     }
   }
 

package/src/pipeline/party-core.test.ts

@@ -325,12 +325,10 @@ describe('PartyCore', () => {
 
     createTestProtocolPair(
       new ReplicatorProtocolPluginFactory(
-        peer1.partyFeedProvider,
-        peer1.party.processor.getActiveFeedSet()
+        peer1.partyFeedProvider
       ).createPlugins().map(r => r.createExtension()),
       new ReplicatorProtocolPluginFactory(
-        partyFeedProvider,
-        peer1.party.processor.getActiveFeedSet()
+        partyFeedProvider
       ).createPlugins().map(r => r.createExtension())
     );
 

package/src/pipeline/party-processor.ts

@@ -20,11 +20,6 @@ import { jsonReplacer } from '@dxos/util';
 
 const log = debug('dxos:echo-db:party-processor');
 
-export interface FeedSetProvider {
-  get(): FeedKey[]
-  added: Event<FeedKey>
-}
-
 /**
  * TODO(burdon): Wrapper/Bridge between HALO APIs.
  */
@@ -108,14 +103,6 @@ export class PartyProcessor {
     return this._state.getAdmittedBy(feedKey);
   }
 
-  // TODO(burdon): Rename xxxProvider.
-  getActiveFeedSet (): FeedSetProvider {
-    return {
-      get: () => this.feedKeys,
-      added: this.feedAdded
-    };
-  }
-
   getOfflineInvitation (invitationID: Buffer) {
     return this._state.getInvitation(invitationID);
   }