@dxos/client 2.23.1-dev.f5b1145e → 2.24.1-dev.3a8cd54e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client",
-  "version": "2.23.1-dev.f5b1145e",
+  "version": "2.24.1-dev.3a8cd54e",
   "license": "AGPL-3.0",
   "author": "DXOS.org",
   "main": "dist/src/index.js",
@@ -10,21 +10,21 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "2.23.1-dev.f5b1145e",
-    "@dxos/codec-protobuf": "2.23.1-dev.f5b1145e",
-    "@dxos/config": "2.23.1-dev.f5b1145e",
-    "@dxos/credentials": "2.23.1-dev.f5b1145e",
-    "@dxos/crypto": "2.23.1-dev.f5b1145e",
-    "@dxos/debug": "2.23.1-dev.f5b1145e",
-    "@dxos/echo-db": "2.23.1-dev.f5b1145e",
-    "@dxos/echo-protocol": "2.23.1-dev.f5b1145e",
-    "@dxos/feed-store": "2.23.1-dev.f5b1145e",
-    "@dxos/model-factory": "2.23.1-dev.f5b1145e",
-    "@dxos/network-manager": "2.23.1-dev.f5b1145e",
-    "@dxos/object-model": "2.23.1-dev.f5b1145e",
-    "@dxos/proto": "2.23.1-dev.f5b1145e",
-    "@dxos/rpc": "2.23.1-dev.f5b1145e",
-    "@dxos/util": "2.23.1-dev.f5b1145e",
+    "@dxos/async": "2.24.1-dev.3a8cd54e",
+    "@dxos/codec-protobuf": "2.24.1-dev.3a8cd54e",
+    "@dxos/config": "2.24.1-dev.3a8cd54e",
+    "@dxos/credentials": "2.24.1-dev.3a8cd54e",
+    "@dxos/crypto": "2.24.1-dev.3a8cd54e",
+    "@dxos/debug": "2.24.1-dev.3a8cd54e",
+    "@dxos/echo-db": "2.24.1-dev.3a8cd54e",
+    "@dxos/echo-protocol": "2.24.1-dev.3a8cd54e",
+    "@dxos/feed-store": "2.24.1-dev.3a8cd54e",
+    "@dxos/model-factory": "2.24.1-dev.3a8cd54e",
+    "@dxos/network-manager": "2.24.1-dev.3a8cd54e",
+    "@dxos/object-model": "2.24.1-dev.3a8cd54e",
+    "@dxos/proto": "2.24.1-dev.3a8cd54e",
+    "@dxos/rpc": "2.24.1-dev.3a8cd54e",
+    "@dxos/util": "2.24.1-dev.3a8cd54e",
     "@wirelineio/registry-client": "~1.1.0-beta.3",
     "abstract-leveldown": "~7.0.0",
     "assert": "^2.0.0",
@@ -35,12 +35,15 @@
     "lodash.defaultsdeep": "^4.6.1",
     "memdown": "^5.1.0",
     "readable-stream": "^3.6.0",
-    "uuid": "^8.3.2"
+    "uuid": "^8.3.2",
+    "@polkadot/util-crypto": "6.11.1",
+    "@polkadot/util": "6.11.1",
+    "@polkadot/keyring": "6.11.1"
   },
   "devDependencies": {
-    "@dxos/random-access-multi-storage": "2.23.1-dev.f5b1145e",
-    "@dxos/testutils": "2.23.0",
-    "@dxos/toolchain-node-library": "2.23.0",
+    "@dxos/random-access-multi-storage": "2.24.1-dev.3a8cd54e",
+    "@dxos/testutils": "2.24.0",
+    "@dxos/toolchain-node-library": "2.24.0",
     "@types/debug": "^4.1.7",
     "@types/expect": "~24.3.0",
     "@types/jest": "^26.0.7",

package/src/api/echo-proxy.ts

@@ -16,20 +16,20 @@ import { ComplexMap, SubscriptionGroup } from '@dxos/util';
 import { ClientServiceHost } from '../client/service-host';
 import { ClientServiceProvider } from '../interfaces';
 import { Invitation, InvitationProxy } from './invitations';
-import { PartyProxy } from './party-proxy';
+import { Party } from './party-proxy';
 
-export class PartyInvitation extends Invitation<PartyProxy> {
+export class PartyInvitation extends Invitation<Party> {
   /**
    * Wait for the invitation flow to complete and return the target party.
    */
-  getParty (): Promise<PartyProxy> {
+  getParty (): Promise<Party> {
     return this.wait();
   }
 }
 
 export class EchoProxy {
   private readonly _modelFactory: ModelFactory;
-  private _parties = new ComplexMap<PublicKey, PartyProxy>(key => key.toHex());
+  private _parties = new ComplexMap<PublicKey, Party>(key => key.toHex());
   private readonly _partiesChanged = new Event();
   private readonly _subscriptions = new SubscriptionGroup();
 
@@ -68,7 +68,7 @@ export class EchoProxy {
     partiesStream.subscribe(async data => {
       for (const party of data.parties ?? []) {
         if (!this._parties.has(party.publicKey)) {
-          const partyProxy = new PartyProxy(this._serviceProvider, this._modelFactory, party);
+          const partyProxy = new Party(this._serviceProvider, this._modelFactory, party);
           await partyProxy.init();
           this._parties.set(partyProxy.key, partyProxy);
 
@@ -114,7 +114,7 @@ export class EchoProxy {
   /**
    * Creates a new party.
    */
-  async createParty (): Promise<PartyProxy> {
+  async createParty (): Promise<Party> {
     const [partyReceivedPromise, partyReceived] = latch();
 
     const party = await this._serviceProvider.services.PartyService.CreateParty();
@@ -135,7 +135,7 @@ export class EchoProxy {
   /**
    * Clones the party from a snapshot.
    */
-  async cloneParty (snapshot: PartySnapshot): Promise<PartyProxy> {
+  async cloneParty (snapshot: PartySnapshot): Promise<Party> {
     const [partyReceivedPromise, partyReceived] = latch();
 
     const party = await this._serviceProvider.services.PartyService.CloneParty(snapshot);
@@ -156,11 +156,11 @@ export class EchoProxy {
   /**
    * Returns an individual party by its key.
    */
-  getParty (partyKey: PartyKey): PartyProxy | undefined {
+  getParty (partyKey: PartyKey): Party | undefined {
     return this._parties.get(partyKey);
   }
 
-  queryParties (): ResultSet<PartyProxy> {
+  queryParties (): ResultSet<Party> {
     return new ResultSet(this._partiesChanged, () => Array.from(this._parties.values()));
   }
 

package/src/api/halo-proxy.ts

@@ -3,11 +3,12 @@
 //
 
 import { Event } from '@dxos/async';
+import { KeyRecord } from '@dxos/credentials';
 import { Contact, CreateProfileOptions, InvitationDescriptor, InvitationOptions, PartyMember, ResultSet } from '@dxos/echo-db';
 import { SubscriptionGroup } from '@dxos/util';
 
 import { ClientServiceProvider } from '../interfaces';
-import { Profile } from '../proto/gen/dxos/client';
+import { Profile, SignRequest } from '../proto/gen/dxos/client';
 import { Invitation, InvitationProxy, InvitationRequest } from './invitations';
 
 export interface CreateInvitationOptions extends InvitationOptions {
@@ -38,17 +39,6 @@ export class HaloProxy extends InvitationProxy {
     return this._profile;
   }
 
-  /**
-   * @deprecated Use `profile` instead.
-  */
-  getProfile (): Profile | undefined {
-    return this._profile;
-  }
-
-  hasProfile (): boolean {
-    return !!this.profile;
-  }
-
   /**
    * Reset the identity and delete all key records.
   */
@@ -65,7 +55,7 @@ export class HaloProxy extends InvitationProxy {
   /**
    * Create Profile. Add Identity key if public and secret key are provided. Then initializes profile with given username.
    * If not public and secret key are provided it relies on keyring to contain an identity key.
-   * @returns {ProfileInfo} User profile info.
+   * @returns User profile info.
    */
   async createProfile ({ publicKey, secretKey, username }: CreateProfileOptions = {}): Promise<Profile> {
     this._profile = await this._serviceProvider.services.ProfileService.CreateProfile({ publicKey, secretKey, username });
@@ -130,6 +120,14 @@ export class HaloProxy extends InvitationProxy {
     );
   }
 
+  async addKeyRecord (keyRecord: KeyRecord) {
+    await this._serviceProvider.services.HaloService.AddKeyRecord({ keyRecord });
+  }
+
+  async sign (request: SignRequest) {
+    return await this._serviceProvider.services.HaloService.Sign(request);
+  }
+
   /**
    * Allocate resources and set-up internal subscriptions.
    *
@@ -143,7 +141,7 @@ export class HaloProxy extends InvitationProxy {
     }, () => {});
     this._subscriptions.push(() => profileStream.close());
 
-    const contactsStream = this._serviceProvider.services.ProfileService.SubscribeContacts();
+    const contactsStream = this._serviceProvider.services.HaloService.SubscribeContacts();
     contactsStream.subscribe(data => {
       this._contacts = data.contacts as PartyMember[];
       this._contactsChanged.emit();

package/src/api/party-proxy.ts

@@ -13,7 +13,7 @@ import { ModelFactory } from '@dxos/model-factory';
 import { ClientServiceHost } from '../client/service-host';
 import { ClientServiceProxy } from '../client/service-proxy';
 import { ClientServiceProvider } from '../interfaces';
-import { Party } from '../proto/gen/dxos/client';
+import { Party as PartyProto } from '../proto/gen/dxos/client';
 import { streamToResultSet } from '../util';
 import { InvitationRequest, InvitationProxy } from './invitations';
 
@@ -21,17 +21,20 @@ export interface CreationInvitationOptions {
   inviteeKey?: PublicKey
 }
 
-export class PartyProxy extends InvitationProxy {
+export class Party extends InvitationProxy {
   private readonly _database?: Database;
 
   private _key: PartyKey;
   private _isOpen: boolean;
   private _isActive: boolean;
 
+  /**
+   * @internal
+   */
   constructor (
     private _serviceProvider: ClientServiceProvider,
     private _modelFactory: ModelFactory,
-    _party: Party
+    _party: PartyProto
   ) {
     super();
     this._key = _party.publicKey;
@@ -72,7 +75,7 @@ export class PartyProxy extends InvitationProxy {
    * Called by EchoProxy to update this party instance.
    * @internal
    */
-  _processPartyUpdate (party: Party) {
+  _processPartyUpdate (party: PartyProto) {
     this._key = party.publicKey;
     this._isOpen = party.isOpen;
     this._isActive = party.isActive;

package/src/client/client.test.ts

@@ -7,7 +7,7 @@ import expect from 'expect';
 import { it as test } from 'mocha';
 
 import { sleep, waitForCondition } from '@dxos/async';
-import { defs } from '@dxos/config';
+import { ConfigV1Object } from '@dxos/config';
 import { generateSeedPhrase, keyPairFromSeedPhrase } from '@dxos/crypto';
 import { throwUnhandledRejection } from '@dxos/debug';
 import { InvitationDescriptor } from '@dxos/echo-db';
@@ -61,10 +61,10 @@ describe('Client', () => {
         afterTest(() => client.destroy());
 
         await client.halo.createProfile({ username: 'test-user' });
-        expect(client.halo.hasProfile()).toBeTruthy();
+        expect(!!client.halo.profile).toBeTruthy();
 
         await expect(client.halo.createProfile({ username: 'test-user' })).rejects.toThrow();
-        expect(client.halo.hasProfile()).toBeTruthy();
+        expect(!!client.halo.profile).toBeTruthy();
       });
 
       test('Recovers a profile with a seed phrase', async () => {
@@ -87,7 +87,7 @@ describe('Client', () => {
         afterTest(() => recoveredClient.destroy());
 
         await recoveredClient.halo.recoverProfile(seedPhrase);
-        await waitForCondition(() => !!recoveredClient.halo.hasProfile(), 2000);
+        await waitForCondition(() => !!recoveredClient.halo.profile, 2000);
 
         expect(recoveredClient.halo.profile).toBeDefined();
         expect(recoveredClient.halo.profile!.publicKey).toEqual(client.halo.profile!.publicKey);
@@ -276,11 +276,14 @@ describe('Client', () => {
   });
 
   test('late-register models after refresh', async () => {
-    const config: defs.Config = {
-      system: {
-        storage: {
-          persistent: true,
-          path: `/tmp/dxos-${Date.now()}`
+    const config: ConfigV1Object = {
+      version: 1,
+      runtime: {
+        client: {
+          storage: {
+            persistent: true,
+            path: `/tmp/dxos-${Date.now()}`
+          }
         }
       }
     };
@@ -300,7 +303,7 @@ describe('Client', () => {
     {
       const client = new Client(config);
       await client.initialize();
-      await waitForCondition(() => client.halo.hasProfile());
+      await waitForCondition(() => !!client.halo.profile);
       await sleep(10); // Make sure all events were processed.
 
       client.registerModel(TestModel);

package/src/client/client.ts

@@ -6,7 +6,7 @@ import assert from 'assert';
 import debug from 'debug';
 
 import { synchronized } from '@dxos/async';
-import { Config, defs } from '@dxos/config';
+import { Config, ConfigV1Object } from '@dxos/config';
 import { InvalidParameterError, TimeoutError } from '@dxos/debug';
 import { OpenProgress, sortItemsTopologically } from '@dxos/echo-db';
 import { DatabaseSnapshot } from '@dxos/echo-protocol';
@@ -17,6 +17,7 @@ import { RpcPort } from '@dxos/rpc';
 import { EchoProxy, HaloProxy } from '../api';
 import { DevtoolsHook } from '../devtools';
 import { ClientServiceProvider, ClientServices, RemoteServiceConnectionTimeout } from '../interfaces';
+import { InvalidConfigurationError } from '../interfaces/errors';
 import { System } from '../proto/gen/dxos/config';
 import { createWindowMessagePort, isNode } from '../util';
 import { ClientServiceHost } from './service-host';
@@ -24,12 +25,17 @@ import { ClientServiceProxy } from './service-proxy';
 
 const log = debug('dxos:client');
 
-export const defaultConfig: defs.Config = {};
+const EXPECTED_CONFIG_VERSION = 1;
 
-export const defaultTestingConfig: defs.Config = {
-  services: {
-    signal: {
-      server: 'ws://localhost:4000'
+export const defaultConfig: ConfigV1Object = { version: 1 };
+
+export const defaultTestingConfig: ConfigV1Object = {
+  version: 1,
+  runtime: {
+    services: {
+      signal: {
+        server: 'ws://localhost:4000'
+      }
     }
   }
 };
@@ -63,19 +69,23 @@ export class Client {
    * Creates the client object based on supplied configuration.
    * Requires initialization after creating by calling `.initialize()`.
    */
-  constructor (config: defs.Config | Config = {}, options: ClientOptions = {}) {
+  constructor (config: ConfigV1Object | Config = { version: 1 }, options: ClientOptions = {}) {
     if (typeof config !== 'object' || config == null) {
       throw new InvalidParameterError('Invalid config.');
     }
     this._config = (config instanceof Config) ? config : new Config(config);
 
+    if (Object.keys(this._config.values).length > 0 && this._config.values.version !== EXPECTED_CONFIG_VERSION) {
+      throw new InvalidConfigurationError(`Expected config version 1, got ${this._config.values.version}.`);
+    }
+
     this._options = options;
 
     // TODO(burdon): Default error level: 'dxos:*:error'
     // TODO(burdon): config.getProperty('system.debug', process.env.DEBUG, '');
-    debug.enable(this._config.values.system?.debug ?? process.env.DEBUG ?? 'dxos:*:error');
+    debug.enable(this._config.values.runtime?.system?.debug ?? process.env.DEBUG ?? 'dxos:*:error');
 
-    this._mode = this._config.get('system.mode', System.Mode.AUTOMATIC)!;
+    this._mode = this._config.get('runtime.client.mode', System.Mode.AUTOMATIC)!;
     log(`mode=${System.Mode[this._mode]}`);
   }
 

package/src/client/local-client.test.ts

@@ -6,7 +6,7 @@ import expect from 'expect';
 import { it as test } from 'mocha';
 
 import { waitForCondition } from '@dxos/async';
-import { defs } from '@dxos/config';
+import { ConfigV1Object } from '@dxos/config';
 
 import { Client } from './client';
 
@@ -31,11 +31,14 @@ describe('Client', () => {
 
   describe('With persistent storage', () => {
     test('persistent storage', async () => {
-      const config: defs.Config = {
-        system: {
-          storage: {
-            persistent: true,
-            path: `/tmp/dxos-${Date.now()}`
+      const config: ConfigV1Object = {
+        version: 1,
+        runtime: {
+          client: {
+            storage: {
+              persistent: true,
+              path: `/tmp/dxos-${Date.now()}`
+            }
           }
         }
       };
@@ -54,7 +57,7 @@ describe('Client', () => {
       {
         const client = new Client(config);
         await client.initialize();
-        await waitForCondition(() => client.halo.hasProfile());
+        await waitForCondition(() => !!client.halo.profile);
 
         expect(client.halo.profile).toBeDefined();
         await client.destroy();

package/src/client/service-host/service-host.ts

@@ -20,8 +20,8 @@ export class ClientServiceHost implements ClientServiceProvider {
     private readonly _config: Config
   ) {
     const { feedStorage, keyStorage, snapshotStorage, metadataStorage } = createStorageObjects(
-      this._config.get('system.storage', {})!,
-      this._config.get('system.enableSnapshots', false)
+      this._config.get('runtime.client.storage', {})!,
+      this._config.get('runtime.client.enableSnapshots', false)
     );
 
     this._echo = new ECHO({
@@ -30,12 +30,12 @@ export class ClientServiceHost implements ClientServiceProvider {
       snapshotStorage,
       metadataStorage,
       networkManagerOptions: {
-        signal: this._config.get('services.signal.server') ? [this._config.get('services.signal.server')!] : undefined,
-        ice: this._config.get('services.ice'),
+        signal: this._config.get('runtime.services.signal.server') ? [this._config.get('runtime.services.signal.server')!] : undefined,
+        ice: this._config.get('runtime.services.ice'),
         log: true
       },
-      snapshots: this._config.get('system.enableSnapshots', false),
-      snapshotInterval: this._config.get('system.snapshotInterval')
+      snapshots: this._config.get('runtime.client.enableSnapshots', false),
+      snapshotInterval: this._config.get('runtime.client.snapshotInterval')
     });
 
     this.services = {

package/src/client/service-host/services/halo.ts

@@ -0,0 +1,75 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import PolkadotKeyring from '@polkadot/keyring';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+import { cryptoWaitReady } from '@polkadot/util-crypto';
+import assert from 'assert';
+
+import { Stream } from '@dxos/codec-protobuf';
+import { KeyRecord, KeyType } from '@dxos/credentials';
+import { ECHO } from '@dxos/echo-db';
+import { SubscriptionGroup } from '@dxos/util';
+
+import { AddKeyRecordRequest, Contacts, HaloService as IHaloService, SignRequest, SignResponse } from '../../../proto/gen/dxos/client';
+import { resultSetToStream } from '../../../util';
+import { CreateServicesOpts } from './interfaces';
+
+export class HaloService implements IHaloService {
+  constructor (private echo: ECHO) {}
+
+  SubscribeContacts (): Stream<Contacts> {
+    if (this.echo.halo.isInitialized) {
+      return resultSetToStream(this.echo.halo.queryContacts(), (contacts): Contacts => ({ contacts }));
+    } else {
+      return new Stream(({ next }) => {
+        const subGroup = new SubscriptionGroup();
+
+        setImmediate(async () => {
+          await this.echo.halo.identityReady.waitForCondition(() => this.echo.halo.isInitialized);
+
+          const resultSet = this.echo.halo.queryContacts();
+          next({ contacts: resultSet.value });
+          subGroup.push(resultSet.update.on(() => next({ contacts: resultSet.value })));
+        });
+
+        return () => subGroup.unsubscribe();
+      });
+    }
+  }
+
+  async AddKeyRecord (request: AddKeyRecordRequest): Promise<void> {
+    assert(request.keyRecord && request.keyRecord.publicKey, 'Missing key record.');
+    await this.echo.halo.keyring.addKeyRecord(request.keyRecord);
+    assert(await this.echo.halo.keyring.getKey(request.keyRecord.publicKey), 'Key not inserted correctly.');
+  }
+
+  private async polkadotSign (key: KeyRecord, payload: SignRequest['payload']): Promise<SignResponse> {
+    await cryptoWaitReady();
+
+    assert(key.secretKey, 'Secret key is missing.');
+
+    const keyring = new PolkadotKeyring({ type: 'sr25519' });
+    const keypair = keyring.addFromUri(key.secretKey.toString());
+
+    const signature = u8aToHex(keypair.sign(hexToU8a(payload), { withType: true }));
+    return {
+      signed: signature
+    };
+  }
+
+  async Sign (request: SignRequest): Promise<SignResponse> {
+    assert(request.publicKey, 'Provide a publicKey of the key that should be used for signing.');
+    const key = await this.echo.halo.keyring.getFullKey(request.publicKey);
+    assert(key, 'Key not found.');
+    if (key.type === KeyType.DXNS) {
+      return this.polkadotSign(key, request.payload);
+    }
+    throw new Error('Only DXNS key signing is supported.');
+  }
+}
+
+export const createHaloService = ({ echo }: CreateServicesOpts): HaloService => {
+  return new HaloService(echo);
+};

package/src/client/service-host/services/party.ts

@@ -8,8 +8,8 @@ import { v4 } from 'uuid';
 import { latch } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { defaultSecretValidator, generatePasscode, SecretProvider } from '@dxos/credentials';
-import { raise } from '@dxos/debug';
-import { ECHO, EchoNotOpenError, InvitationDescriptor, InvitationDescriptorType, PartyNotFoundError } from '@dxos/echo-db';
+import { InvalidStateError, raise } from '@dxos/debug';
+import { ECHO, InvitationDescriptor, InvitationDescriptorType, PartyNotFoundError } from '@dxos/echo-db';
 
 import {
   InvitationState,
@@ -50,7 +50,7 @@ class PartyService implements IPartyService {
           }
         });
       } catch (error) {
-        if (error instanceof EchoNotOpenError) {
+        if (error instanceof InvalidStateError) {
           // Do nothing.
         } else {
           throw error;
@@ -156,7 +156,7 @@ class PartyService implements IPartyService {
               next({ state: InvitationState.CONNECTED });
               return Buffer.from(secret);
             };
-            invitation = await party.createInvitation({
+            invitation = await party.invitationManager.createInvitation({
               secretProvider,
               secretValidator: defaultSecretValidator
             }, {
@@ -169,7 +169,7 @@ class PartyService implements IPartyService {
             assert(invitation.type === InvitationDescriptorType.INTERACTIVE);
             invitation.secret = Buffer.from(secret);
           } else {
-            invitation = await party.createOfflineInvitation(request.inviteeKey);
+            invitation = await party.invitationManager.createOfflineInvitation(request.inviteeKey);
           }
 
           next({ state: InvitationState.WAITING_FOR_CONNECTION, descriptor: invitation.toProto() });
@@ -256,7 +256,7 @@ class PartyService implements IPartyService {
     }
   }
 
-  CreateSnapshot (request: CreateSnaspotRequest): Promise<PartySnapshot> {
+  async CreateSnapshot (request: CreateSnaspotRequest): Promise<PartySnapshot> {
     assert(request.partyKey);
     const party = this.echo.getParty(request.partyKey) ?? raise(new PartyNotFoundError(request.partyKey));
     return party.createSnapshot();

package/src/client/service-host/services/profile.ts

@@ -9,22 +9,11 @@ import { latch } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { defaultSecretValidator, generatePasscode, SecretProvider } from '@dxos/credentials';
 import { ECHO, InvitationDescriptor } from '@dxos/echo-db';
-import { SubscriptionGroup } from '@dxos/util';
 
 import {
-  InvitationState,
-  ProfileService as IProfileService,
-  AuthenticateInvitationRequest,
-  SubscribeProfileResponse,
-  InvitationRequest,
-  CreateProfileRequest,
-  Contacts,
-  RedeemedInvitation,
-  Profile
-  , RecoverProfileRequest
+  AuthenticateInvitationRequest, CreateProfileRequest, InvitationRequest, InvitationState, Profile, ProfileService as IProfileService, RecoverProfileRequest, RedeemedInvitation, SubscribeProfileResponse
 } from '../../../proto/gen/dxos/client';
 import { InvitationDescriptor as InvitationDescriptorProto } from '../../../proto/gen/dxos/echo/invitation';
-import { resultSetToStream } from '../../../util';
 import { CreateServicesOpts, InviteeInvitation, InviteeInvitations } from './interfaces';
 
 export class ProfileService implements IProfileService {
@@ -122,26 +111,6 @@ export class ProfileService implements IProfileService {
     invitation.secret = request.secret;
     invitation.secretTrigger?.();
   }
-
-  SubscribeContacts (): Stream<Contacts> {
-    if (this.echo.halo.isInitialized) {
-      return resultSetToStream(this.echo.halo.queryContacts(), (contacts): Contacts => ({ contacts }));
-    } else {
-      return new Stream(({ next }) => {
-        const subGroup = new SubscriptionGroup();
-
-        setImmediate(async () => {
-          await this.echo.halo.identityReady.waitForCondition(() => this.echo.halo.isInitialized);
-
-          const resultSet = this.echo.halo.queryContacts();
-          next({ contacts: resultSet.value });
-          subGroup.push(resultSet.update.on(() => next({ contacts: resultSet.value })));
-        });
-
-        return () => subGroup.unsubscribe();
-      });
-    }
-  }
 }
 
 export const createProfileService = ({ echo }: CreateServicesOpts): ProfileService => {

package/src/client/service-host/services/services.ts

@@ -3,6 +3,7 @@
 //
 
 import { ClientServices } from '../../../interfaces';
+import { createHaloService } from './halo';
 import { CreateServicesOpts } from './interfaces';
 import { createPartyService } from './party';
 import { createProfileService } from './profile';
@@ -12,6 +13,7 @@ export const createServices = (opts: CreateServicesOpts): Omit<ClientServices, '
   return {
     SystemService: createSystemService(opts),
     ProfileService: createProfileService(opts),
+    HaloService: createHaloService(opts),
     PartyService: createPartyService(opts),
     DataService: opts.echo.dataService,
     TracingService: {

package/src/index.ts

@@ -9,3 +9,18 @@ export * from './devtools/devtools-context';
 export * from './devtools/devtools-host-events';
 export * from './util';
 export * as proto from './proto/gen';
+
+export {
+  Entity,
+  Item,
+  Link,
+  Database,
+  Selection,
+  SelectionResult,
+  InvitationDescriptor,
+  InvitationDescriptorType,
+  OpenProgress,
+  PartyMember,
+  ResultSet,
+  PARTY_ITEM_TYPE
+} from '@dxos/echo-db';

package/src/interfaces/client-service-provider.ts

@@ -7,13 +7,14 @@ import { DataService, schema as schemaProtocol } from '@dxos/echo-protocol';
 import { createServiceBundle } from '@dxos/rpc';
 
 import { schema } from '../proto/gen';
-import { PartyService, ProfileService, SystemService } from '../proto/gen/dxos/client';
+import { PartyService, ProfileService, SystemService, HaloService } from '../proto/gen/dxos/client';
 import { DevtoolsHost, TracingService } from '../proto/gen/dxos/devtools';
 
 // TODO(burdon): Is there a way to mark TS (generics) so cast isn't required for result of stream?
 export interface ClientServices {
   SystemService: SystemService;
   ProfileService: ProfileService;
+  HaloService: HaloService;
   PartyService: PartyService;
   DataService: DataService;
   DevtoolsHost: DevtoolsHost;
@@ -24,6 +25,7 @@ export const clientServiceBundle = createServiceBundle<ClientServices>({
   SystemService: schema.getService('dxos.client.SystemService'),
   ProfileService: schema.getService('dxos.client.ProfileService'),
   PartyService: schema.getService('dxos.client.PartyService'),
+  HaloService: schema.getService('dxos.client.HaloService'),
   // DataService is provided and implemented internally in ECHO so we import it from there.
   DataService: schemaProtocol.getService('dxos.echo.service.DataService'),
   DevtoolsHost: schema.getService('dxos.devtools.DevtoolsHost'),