@dxos/echo-db 2.33.2 → 2.33.3-dev.0cff904f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-db",
-  "version": "2.33.2",
+  "version": "2.33.3-dev.0cff904f",
   "description": "ECHO database.",
   "license": "MIT",
   "main": "dist/src/index.js",
@@ -10,22 +10,22 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "2.33.2",
-    "@dxos/codec-protobuf": "2.33.2",
-    "@dxos/credentials": "2.33.2",
-    "@dxos/crypto": "2.33.2",
-    "@dxos/debug": "2.33.2",
-    "@dxos/echo-protocol": "2.33.2",
-    "@dxos/feed-store": "2.33.2",
-    "@dxos/mesh-protocol": "2.33.2",
-    "@dxos/model-factory": "2.33.2",
-    "@dxos/network-manager": "2.33.2",
-    "@dxos/object-model": "2.33.2",
-    "@dxos/protocol-plugin-presence": "2.33.2",
-    "@dxos/protocol-plugin-replicator": "2.33.2",
-    "@dxos/protocols": "2.33.2",
-    "@dxos/random-access-multi-storage": "2.33.2",
-    "@dxos/util": "2.33.2",
+    "@dxos/async": "2.33.3-dev.0cff904f",
+    "@dxos/codec-protobuf": "2.33.3-dev.0cff904f",
+    "@dxos/credentials": "2.33.3-dev.0cff904f",
+    "@dxos/crypto": "2.33.3-dev.0cff904f",
+    "@dxos/debug": "2.33.3-dev.0cff904f",
+    "@dxos/echo-protocol": "2.33.3-dev.0cff904f",
+    "@dxos/feed-store": "2.33.3-dev.0cff904f",
+    "@dxos/mesh-protocol": "2.33.3-dev.0cff904f",
+    "@dxos/model-factory": "2.33.3-dev.0cff904f",
+    "@dxos/network-manager": "2.33.3-dev.0cff904f",
+    "@dxos/object-model": "2.33.3-dev.0cff904f",
+    "@dxos/protocol-plugin-presence": "2.33.3-dev.0cff904f",
+    "@dxos/protocol-plugin-replicator": "2.33.3-dev.0cff904f",
+    "@dxos/protocols": "2.33.3-dev.0cff904f",
+    "@dxos/random-access-multi-storage": "2.33.3-dev.0cff904f",
+    "@dxos/util": "2.33.3-dev.0cff904f",
     "base-x": "~3.0.9",
     "buffer-json-encoding": "^1.0.2",
     "debug": "^4.3.3",

package/src/echo.test.ts

@@ -264,8 +264,8 @@ describe('ECHO', () => {
     const a = await setup({ createProfile: true });
     const b = await setup();
 
-    expect(a.halo.isInitialized).toEqual(true);
-    expect(b.halo.isInitialized).toEqual(false);
+    expect(!!a.halo.identity).toEqual(true);
+    expect(!!b.halo.identity).toEqual(false);
 
     expect(a.queryParties().value.length).toBe(0);
     await a.createParty();
@@ -430,11 +430,11 @@ describe('ECHO', () => {
     const b1 = await setup({ createProfile: true });
     const b2 = await setup();
 
-    expect(a1.halo.isInitialized).toBeTruthy();
-    expect(a2.halo.isInitialized).toBeFalsy();
+    expect(a1.halo.identity).toBeTruthy();
+    expect(a2.halo.identity).toBeFalsy();
 
-    expect(b1.halo.isInitialized).toBeTruthy();
-    expect(b2.halo.isInitialized).toBeFalsy();
+    expect(b1.halo.identity).toBeTruthy();
+    expect(b2.halo.identity).toBeFalsy();
 
     await Promise.all([
       (async () => {
@@ -529,13 +529,13 @@ describe('ECHO', () => {
 
     const b = await setup();
 
-    expect(a.halo.isInitialized).toBeTruthy();
-    expect(b.halo.isInitialized).toBeFalsy();
+    expect(a.halo.identity).toBeTruthy();
+    expect(b.halo.identity).toBeFalsy();
 
     // And then redeem it on nodeB.
     await b.halo.recover(seedPhrase);
-    expect(a.halo.isInitialized).toBeTruthy();
-    expect(b.halo.isInitialized).toBeTruthy();
+    expect(a.halo.identity).toBeTruthy();
+    expect(b.halo.identity).toBeTruthy();
 
     // Now create a Party on A and make sure it gets opened on both A and B.
     expect(a.queryParties().value.length).toBe(0);

package/src/echo.ts

@@ -376,7 +376,7 @@ export class ECHO {
     assert(this._partyManager.isOpen, new InvalidStateError());
 
     const actualSecretProvider =
-      secretProvider ?? OfflineInvitationClaimer.createSecretProvider(this.halo.identity ?? raise(new IdentityNotInitializedError()));
+      secretProvider ?? OfflineInvitationClaimer.createSecretProvider(this.halo.identity?.createCredentialsSigner() ?? raise(new IdentityNotInitializedError()));
 
     return this._partyManager.joinParty(invitationDescriptor, actualSecretProvider);
   }

package/src/halo/halo.ts

@@ -46,6 +46,8 @@ export class HALO {
   private readonly _keyring: Keyring;
   private readonly _identityManager: IdentityManager;
 
+  private _isOpen = false;
+
   constructor ({
     keyring,
     networkManager,
@@ -85,7 +87,7 @@ export class HALO {
    * Whether the current identity manager has been initialized.
    */
   get isInitialized (): boolean {
-    return this._identityManager.initialized;
+    return this._isOpen;
   }
 
   /**
@@ -129,6 +131,7 @@ export class HALO {
    *
    * Loads the saved identity from disk. Is called by client.
    */
+  @synchronized
   async open (onProgressCallback?: ((progress: OpenProgress) => void) | undefined) {
     // TODO(burdon): Replace with events.
     onProgressCallback?.({ haloOpened: false });
@@ -137,12 +140,16 @@ export class HALO {
     await this._identityManager.loadFromStorage();
 
     onProgressCallback?.({ haloOpened: true });
+
+    this._isOpen = true;
   }
 
   /**
    * Closes HALO. Automatically called when client is destroyed.
    */
+  @synchronized
   async close () {
+    this._isOpen = false;
     await this._identityManager.close();
   }
 

package/src/halo/identity-manager.ts

@@ -7,6 +7,7 @@ import debug from 'debug';
 
 import { Event, synchronized, waitForCondition } from '@dxos/async';
 import { Filter, KeyRecord, Keyring, KeyType, SecretProvider } from '@dxos/credentials';
+import { failUndefined } from '@dxos/debug';
 
 import { InvitationDescriptor } from '../invitations';
 import { MetadataStore } from '../pipeline';
@@ -34,25 +35,23 @@ export class IdentityManager {
     return this._identity;
   }
 
-  get initialized (): boolean {
-    return this._identity !== undefined &&
-      !!this._identity.halo &&
-      this._identity.halo.isOpen &&
-      !!this._identity.halo!.memberKeys.length &&
-      !!this._identity.halo!.identityGenesis &&
-      !!this._identity.deviceKeyChain;
-  }
-
   private async _initialize (halo: HaloParty) {
     assert(halo.isOpen, 'HALO must be open.');
 
-    this._identity = new Identity(this._keyring, halo);
-
-    // Wait for the minimum set of keys and messages we need for proper function.
-    await waitForCondition(() => this.initialized);
+    // Wait for the minimum set of keys and messages we need for proper function:
+    //
+    // - KeyAdmit message for the current device so we can build the device KeyChain.
+    // - Identity genesis so it can be copied into newly joined parties.
+    //
+    const deviceKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.DEVICE })) ?? failUndefined();
+    await waitForCondition(() =>
+      halo.processor.isMemberKey(deviceKey.publicKey) &&
+      halo.identityGenesis
+    );
 
-    log('HALO initialized.');
+    this._identity = new Identity(this._keyring, halo);
     this.ready.emit();
+    log('HALO initialized.');
   }
 
   async close () {

package/src/halo/identity.ts

@@ -2,13 +2,14 @@
 // Copyright 2021 DXOS.org
 //
 
+import assert from 'assert';
 import debug from 'debug';
 
-import { Filter, KeyChain, KeyRecord, Keyring, KeyType, Signer } from '@dxos/credentials';
-import { raise } from '@dxos/debug';
+import { Filter, KeyChain, KeyRecord, Keyring, KeyType, SignedMessage, Signer } from '@dxos/credentials';
+import { failUndefined } from '@dxos/debug';
 
-import { IdentityNotInitializedError } from '../errors';
 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,10 +21,10 @@ const log = debug('dxos:echo-db:identity');
  *
  * Acts as a read-only view into IdentityManager.
  */
-export class Identity {
-  private _identityKey?: KeyRecord;
-  private _deviceKey?: KeyRecord;
-  private _deviceKeyChain?: KeyChain;
+export class Identity implements IdentityCredentials {
+  private readonly _identityKey: KeyRecord;
+  private readonly _deviceKey: KeyRecord;
+  private readonly _deviceKeyChain: KeyChain;
 
   /**
    * @param _halo HALO party. Must be open.
@@ -31,54 +32,55 @@ export class Identity {
   constructor (
     private readonly _keyring: Keyring,
     private readonly _halo: HaloParty
-  ) {}
+  ) {
+    this._identityKey = this._keyring.findKey(Filter.matches({ type: KeyType.IDENTITY, own: true, trusted: true })) ?? failUndefined();
+    this._deviceKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.DEVICE })) ?? failUndefined();
+    this._deviceKeyChain = getDeviceKeyChainFromHalo(this._halo, this.deviceKey);
+    assert(this._halo.identityGenesis);
+  }
 
   get signer (): Signer {
     return this._keyring;
   }
 
-  get identityKey (): KeyRecord | undefined {
-    if (!this._identityKey) {
-      this._identityKey = this._keyring.findKey(Filter.matches({ type: KeyType.IDENTITY, own: true, trusted: true }));
-    }
+  get keyring (): Keyring {
+    return this._keyring;
+  }
 
+  get identityKey (): KeyRecord {
     return this._identityKey;
   }
 
-  get deviceKey (): KeyRecord | undefined {
-    if (!this._deviceKey) {
-      this._deviceKey = this._keyring.findKey(Keyring.signingFilter({ type: KeyType.DEVICE }));
-    }
-
+  get deviceKey (): KeyRecord {
     return this._deviceKey;
   }
 
-  get deviceKeyChain (): KeyChain | undefined {
-    if (!this._deviceKeyChain) {
-      this._deviceKeyChain = this.deviceKey && this._halo ? getDeviceKeyChainFromHalo(this._halo, this.deviceKey) : undefined;
-    }
-
+  get deviceKeyChain (): KeyChain {
     return this._deviceKeyChain;
   }
 
-  get preferences (): Preferences | undefined {
-    return this._halo?.preferences;
+  get displayName (): string | undefined {
+    return this.identityInfo?.signed.payload.displayName;
   }
 
-  get contacts (): ContactManager | undefined {
-    return this._halo?.contacts;
+  /**
+   * Contains profile username.
+   * Can be missing if the username wasn't provided when profile was created.
+   */
+  get identityInfo (): SignedMessage | undefined {
+    return this._halo.identityInfo;
   }
 
-  get displayName (): string | undefined {
-    return this.identityInfo?.signed.payload.displayName;
+  get identityGenesis (): SignedMessage {
+    return this._halo.identityGenesis ?? failUndefined();
   }
 
-  get identityInfo () {
-    return this._halo?.identityInfo;
+  get preferences (): Preferences {
+    return this._halo.preferences;
   }
 
-  get identityGenesis () {
-    return this._halo?.identityGenesis;
+  get contacts (): ContactManager {
+    return this._halo.contacts;
   }
 
   /**
@@ -88,16 +90,12 @@ export class Identity {
     return this._halo;
   }
 
-  get keyring () {
-    return this._keyring;
-  }
-
   createCredentialsSigner (): CredentialsSigner {
     return new CredentialsSigner(
       this._keyring,
-      () => this.identityKey ?? raise(new IdentityNotInitializedError()),
-      () => this.deviceKey ?? raise(new IdentityNotInitializedError()),
-      () => this.deviceKeyChain ?? this.deviceKey ?? raise(new IdentityNotInitializedError())
+      this.identityKey,
+      this.deviceKey,
+      this.deviceKeyChain
     );
   }
 }
@@ -112,7 +110,7 @@ function getDeviceKeyChainFromHalo (halo: HaloParty, deviceKey: KeyRecord) {
       halo.feedKeys
     );
   } catch (err: any) {
-    log('Unable to locate device KeyChain:', err); // TODO(burdon): ???
-    return undefined;
+    log('Unable to locate device KeyChain:', err);
+    throw err;
   }
 }

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

@@ -21,11 +21,10 @@ import {
   codec
 } from '@dxos/credentials';
 import { keyToBuffer, keyToString, PublicKey, randomBytes } from '@dxos/crypto';
-import { raise } from '@dxos/debug';
 import { FullyConnectedTopology, NetworkManager } from '@dxos/network-manager';
 
-import { IdentityNotInitializedError, InvalidInvitationError } from '../errors';
-import { Identity } from '../halo';
+import { InvalidInvitationError } from '../errors';
+import { CredentialsSigner } from '../protocol';
 import { greetingProtocolProvider } from './greeting-protocol-provider';
 import { GreetingState } from './greeting-responder';
 import { InvitationDescriptor, InvitationDescriptorType } from './invitation-descriptor';
@@ -170,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 ?? raise(new IdentityNotInitializedError()),
-          identity.deviceKeyChain ?? raise(new IdentityNotInitializedError()),
+          credentials.getIdentityKey(),
+          credentials.getDeviceSigningKeys(),
           undefined,
           info!.authNonce.value)
       ));

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,
@@ -52,8 +52,6 @@ export class PartyFactory {
   @timed(5_000)
   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.');
 
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
@@ -66,7 +64,7 @@ export class PartyFactory {
 
     // PartyGenesis (self-signed by Party).
     await party.processor.writeHaloMessage(createPartyGenesisMessage(
-      identity.signer,
+      identity.keyring,
       partyKey,
       writableFeed.key,
       partyKey)
@@ -74,7 +72,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])
@@ -82,7 +80,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]
@@ -91,7 +89,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]
@@ -138,13 +136,12 @@ export class PartyFactory {
     );
 
     await party.open();
-    assert(identity.identityKey, 'No identity key.');
     const isHalo = identity.identityKey.publicKey.equals(partyKey);
     const signingKey = isHalo ? identity.deviceKey : identity.deviceKeyChain;
     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]
@@ -213,7 +210,7 @@ export class PartyFactory {
       async (partyKey, nonce) => [createDataPartyAdmissionMessages(
         identity.createCredentialsSigner(),
         partyKey,
-        identity.identityGenesis ?? raise(new IdentityNotInitializedError()),
+        identity.identityGenesis,
         nonce
       )]
     );
@@ -223,13 +220,11 @@ export class PartyFactory {
     const party = await this.addParty(partyKey, hints);
     await initiator.destroy();
     if (!haloInvitation) {
-      assert(identity.deviceKeyChain);
-
       // Copy our signed IdentityInfo into the new Party.
       const infoMessage = identity.identityInfo;
       if (infoMessage) {
         await party.processor.writeHaloMessage(createEnvelopeMessage(
-          identity.signer,
+          identity.keyring,
           partyKey,
           wrapMessage(infoMessage),
           [identity.deviceKeyChain]
@@ -244,8 +239,6 @@ export class PartyFactory {
     const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
 
     assert(!this._options.readOnly, 'PartyFactory is read-only');
-    assert(identity.identityGenesis, 'IdentityGenesis must exist');
-    assert(identity.deviceKeyChain, 'Device KeyChain must exist');
 
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
     const party = await this.constructParty(partyKey.publicKey);
@@ -257,7 +250,7 @@ export class PartyFactory {
 
     // PartyGenesis (self-signed by Party).
     await party.processor.writeHaloMessage(createPartyGenesisMessage(
-      identity.signer,
+      identity.keyring,
       partyKey,
       writableFeed.key,
       partyKey)
@@ -265,7 +258,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]
@@ -273,7 +266,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]
@@ -282,7 +275,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
   ) {}
 
@@ -74,10 +74,11 @@ export class PartyManager {
 
     let partyKeys = this._metadataStore.parties.map(party => party.key).filter(boolGuard);
 
+    // Identity may be undefined, for example, on the first start.
     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) {
       partyKeys = partyKeys.filter(partyKey => !partyKey.equals(identity.identityKey!.publicKey));
     }