@dxos/client 2.24.1-dev.79448ad7 → 2.25.1-dev.3e7251f9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client",
-  "version": "2.24.1-dev.79448ad7",
+  "version": "2.25.1-dev.3e7251f9",
   "license": "AGPL-3.0",
   "author": "DXOS.org",
   "main": "dist/src/index.js",
@@ -10,21 +10,24 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "2.24.1-dev.79448ad7",
-    "@dxos/codec-protobuf": "2.24.1-dev.79448ad7",
-    "@dxos/config": "2.24.1-dev.79448ad7",
-    "@dxos/credentials": "2.24.1-dev.79448ad7",
-    "@dxos/crypto": "2.24.1-dev.79448ad7",
-    "@dxos/debug": "2.24.1-dev.79448ad7",
-    "@dxos/echo-db": "2.24.1-dev.79448ad7",
-    "@dxos/echo-protocol": "2.24.1-dev.79448ad7",
-    "@dxos/feed-store": "2.24.1-dev.79448ad7",
-    "@dxos/model-factory": "2.24.1-dev.79448ad7",
-    "@dxos/network-manager": "2.24.1-dev.79448ad7",
-    "@dxos/object-model": "2.24.1-dev.79448ad7",
-    "@dxos/proto": "2.24.1-dev.79448ad7",
-    "@dxos/rpc": "2.24.1-dev.79448ad7",
-    "@dxos/util": "2.24.1-dev.79448ad7",
+    "@dxos/async": "2.25.1-dev.3e7251f9",
+    "@dxos/codec-protobuf": "2.25.1-dev.3e7251f9",
+    "@dxos/config": "2.25.1-dev.3e7251f9",
+    "@dxos/credentials": "2.25.1-dev.3e7251f9",
+    "@dxos/crypto": "2.25.1-dev.3e7251f9",
+    "@dxos/debug": "2.25.1-dev.3e7251f9",
+    "@dxos/echo-db": "2.25.1-dev.3e7251f9",
+    "@dxos/echo-protocol": "2.25.1-dev.3e7251f9",
+    "@dxos/feed-store": "2.25.1-dev.3e7251f9",
+    "@dxos/model-factory": "2.25.1-dev.3e7251f9",
+    "@dxos/network-manager": "2.25.1-dev.3e7251f9",
+    "@dxos/object-model": "2.25.1-dev.3e7251f9",
+    "@dxos/proto": "2.25.1-dev.3e7251f9",
+    "@dxos/rpc": "2.25.1-dev.3e7251f9",
+    "@dxos/util": "2.25.1-dev.3e7251f9",
+    "@polkadot/keyring": "6.11.1",
+    "@polkadot/util": "6.11.1",
+    "@polkadot/util-crypto": "6.11.1",
     "@wirelineio/registry-client": "~1.1.0-beta.3",
     "abstract-leveldown": "~7.0.0",
     "assert": "^2.0.0",
@@ -38,9 +41,9 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@dxos/random-access-multi-storage": "2.24.1-dev.79448ad7",
-    "@dxos/testutils": "2.24.0",
-    "@dxos/toolchain-node-library": "2.24.0",
+    "@dxos/random-access-multi-storage": "2.25.1-dev.3e7251f9",
+    "@dxos/testutils": "2.25.0",
+    "@dxos/toolchain-node-library": "2.25.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();
 
@@ -63,12 +63,14 @@ export class EchoProxy {
   /**
    * @internal
    */
-  _open () {
-    const partiesStream = this._serviceProvider.services.PartyService.SubscribeParties();
+  async _open () {
+    const gotParties = this._partiesChanged.waitForCount(1);
+
+    const partiesStream = this._serviceProvider.services.PartyService.subscribeParties();
     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);
 
@@ -79,7 +81,7 @@ export class EchoProxy {
             }
           });
 
-          const partyStream = this._serviceProvider.services.PartyService.SubscribeToParty({ partyKey: party.publicKey });
+          const partyStream = this._serviceProvider.services.PartyService.subscribeToParty({ partyKey: party.publicKey });
           partyStream.subscribe(async ({ party }) => {
             if (!party) {
               return;
@@ -94,6 +96,8 @@ export class EchoProxy {
       this._partiesChanged.emit();
     }, () => {});
     this._subscriptions.push(() => partiesStream.close());
+
+    await gotParties;
   }
 
   /**
@@ -114,10 +118,10 @@ 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();
+    const party = await this._serviceProvider.services.PartyService.createParty();
 
     const handler = () => {
       if (this._parties.has(party.publicKey)) {
@@ -135,10 +139,10 @@ 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);
+    const party = await this._serviceProvider.services.PartyService.cloneParty(snapshot);
 
     const handler = () => {
       if (this._parties.has(party.publicKey)) {
@@ -156,11 +160,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()));
   }
 
@@ -170,12 +174,12 @@ export class EchoProxy {
    * To be used with `party.createInvitation` on the inviter side.
    */
   acceptInvitation (invitationDescriptor: InvitationDescriptor): PartyInvitation {
-    const invitationProcessStream = this._serviceProvider.services.PartyService.AcceptInvitation(invitationDescriptor.toProto());
+    const invitationProcessStream = this._serviceProvider.services.PartyService.acceptInvitation(invitationDescriptor.toProto());
     const { authenticate, waitForFinish } = InvitationProxy.handleInvitationRedemption({
       stream: invitationProcessStream,
       invitationDescriptor,
       onAuthenticate: async (request) => {
-        await this._serviceProvider.services.PartyService.AuthenticateInvitation(request);
+        await this._serviceProvider.services.PartyService.authenticateInvitation(request);
       }
     });
 

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 {
@@ -42,7 +43,7 @@ export class HaloProxy extends InvitationProxy {
    * Reset the identity and delete all key records.
   */
   async reset () {
-    await this._serviceProvider.services.SystemService.Reset();
+    await this._serviceProvider.services.SystemService.reset();
     this._profileChanged.emit();
   }
 
@@ -57,7 +58,7 @@ export class HaloProxy extends InvitationProxy {
    * @returns User profile info.
    */
   async createProfile ({ publicKey, secretKey, username }: CreateProfileOptions = {}): Promise<Profile> {
-    this._profile = await this._serviceProvider.services.ProfileService.CreateProfile({ publicKey, secretKey, username });
+    this._profile = await this._serviceProvider.services.ProfileService.createProfile({ publicKey, secretKey, username });
     return this._profile;
   }
 
@@ -72,7 +73,7 @@ export class HaloProxy extends InvitationProxy {
    * Joins an existing identity HALO from a recovery seed phrase.
    */
   async recoverProfile (seedPhrase: string) {
-    this._profile = await this._serviceProvider.services.ProfileService.RecoverProfile({ seedPhrase });
+    this._profile = await this._serviceProvider.services.ProfileService.recoverProfile({ seedPhrase });
     return this._profile;
   }
 
@@ -85,7 +86,7 @@ export class HaloProxy extends InvitationProxy {
    * To be used with `client.halo.joinHaloInvitation` on the invitee side.
    */
   async createInvitation (): Promise<InvitationRequest> {
-    const stream = await this._serviceProvider.services.ProfileService.CreateInvitation();
+    const stream = await this._serviceProvider.services.ProfileService.createInvitation();
     return this.createInvitationRequest({ stream });
   }
 
@@ -98,12 +99,12 @@ export class HaloProxy extends InvitationProxy {
    * To be used with `client.halo.createHaloInvitation` on the inviter side.
   */
   acceptInvitation (invitationDescriptor: InvitationDescriptor): Invitation {
-    const invitationProcessStream = this._serviceProvider.services.ProfileService.AcceptInvitation(invitationDescriptor.toProto());
+    const invitationProcessStream = this._serviceProvider.services.ProfileService.acceptInvitation(invitationDescriptor.toProto());
     const { authenticate, waitForFinish } = InvitationProxy.handleInvitationRedemption({
       stream: invitationProcessStream,
       invitationDescriptor,
       onAuthenticate: async (request) => {
-        await this._serviceProvider.services.ProfileService.AuthenticateInvitation(request);
+        await this._serviceProvider.services.ProfileService.authenticateInvitation(request);
       }
     });
 
@@ -119,25 +120,38 @@ 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.
    *
    * @internal
    */
-  _open () {
-    const profileStream = this._serviceProvider.services.ProfileService.SubscribeProfile();
+  async _open () {
+    const gotProfile = this._profileChanged.waitForCount(1);
+    const gotContacts = this._contactsChanged.waitForCount(1);
+
+    const profileStream = this._serviceProvider.services.ProfileService.subscribeProfile();
     profileStream.subscribe(data => {
       this._profile = data.profile;
       this._profileChanged.emit();
     }, () => {});
     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();
     }, () => {});
     this._subscriptions.push(() => contactsStream.close());
+
+    await Promise.all([gotProfile, gotContacts]);
   }
 
   /**

package/src/api/party-proxy.ts

@@ -5,7 +5,7 @@
 import { PublicKey } from '@dxos/crypto';
 import { failUndefined } from '@dxos/debug';
 import {
-  ActivationOptions, Database, PARTY_ITEM_TYPE, PARTY_TITLE_PROPERTY, RemoteDatabaseBackend
+  ActivationOptions, Database, PARTY_ITEM_TYPE, PARTY_TITLE_PROPERTY, RemoteDatabaseBackend, RootSelector
 } from '@dxos/echo-db';
 import { PartyKey } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
@@ -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;
@@ -106,7 +109,7 @@ export class PartyProxy extends InvitationProxy {
   }
 
   async setOpen (open: boolean) {
-    await this._serviceProvider.services.PartyService.SetPartyState({
+    await this._serviceProvider.services.PartyService.setPartyState({
       partyKey: this.key,
       open
     });
@@ -115,13 +118,20 @@ export class PartyProxy extends InvitationProxy {
   async setActive (active: boolean, options: ActivationOptions) {
     const activeGlobal = options.global ? active : undefined;
     const activeDevice = options.device ? active : undefined;
-    await this._serviceProvider.services.PartyService.SetPartyState({
+    await this._serviceProvider.services.PartyService.setPartyState({
       partyKey: this.key,
       activeGlobal,
       activeDevice
     });
   }
 
+  /**
+   * Returns a selection context, which can be used to traverse the object graph.
+   */
+  get select (): RootSelector {
+    return this.database.select.bind(this.database);
+  }
+
   /**
    * Creates an invitation to a given party.
    * The Invitation flow requires the inviter and invitee to be online at the same time.
@@ -133,13 +143,13 @@ export class PartyProxy extends InvitationProxy {
    * @param inviteeKey Public key of the invitee. In this case no secret exchange is required, but only the specified recipient can accept the invitation.
    */
   async createInvitation ({ inviteeKey }: CreationInvitationOptions = {}): Promise<InvitationRequest> {
-    const stream = this._serviceProvider.services.PartyService.CreateInvitation({ partyKey: this.key, inviteeKey });
+    const stream = this._serviceProvider.services.PartyService.createInvitation({ partyKey: this.key, inviteeKey });
     return this.createInvitationRequest({ stream });
   }
 
   queryMembers () {
     return streamToResultSet(
-      this._serviceProvider.services.PartyService.SubscribeMembers({ partyKey: this.key }),
+      this._serviceProvider.services.PartyService.subscribeMembers({ partyKey: this.key }),
       (response) => response?.members ?? []
     );
   }
@@ -161,11 +171,11 @@ export class PartyProxy extends InvitationProxy {
   }
 
   private getPropertiesItem () {
-    const items = this.database.select(s => s.filter({ type: PARTY_ITEM_TYPE }).items).getValue();
+    const items = this.database.select({ type: PARTY_ITEM_TYPE }).query().result;
     return items[0];
   }
 
   createSnapshot () {
-    return this._serviceProvider.services.PartyService.CreateSnapshot({ partyKey: this.key });
+    return this._serviceProvider.services.PartyService.createSnapshot({ partyKey: this.key });
   }
 }

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

@@ -31,24 +31,24 @@ describe('Client Services', () => {
       const invitee = await setup();
       afterTest(() => invitee.client.destroy());
 
-      await inviter.services.ProfileService.CreateProfile({ username: 'test-user' });
+      await inviter.services.ProfileService.createProfile({ username: 'test-user' });
 
       const invitation = await new Promise<InvitationRequest>((resolve, reject) => {
-        inviter.services.ProfileService.CreateInvitation().subscribe(resolve, reject);
+        inviter.services.ProfileService.createInvitation().subscribe(resolve, reject);
       });
       assert(invitation.descriptor);
 
       const redeemedInvitation = await new Promise<RedeemedInvitation>((resolve, reject) => {
-        invitee.services.ProfileService.AcceptInvitation(invitation.descriptor!).subscribe(resolve, reject);
+        invitee.services.ProfileService.acceptInvitation(invitation.descriptor!).subscribe(resolve, reject);
       });
 
-      await invitee.services.ProfileService.AuthenticateInvitation({
+      await invitee.services.ProfileService.authenticateInvitation({
         processId: redeemedInvitation.id,
         secret: invitation.descriptor.secret
       });
 
       const [inviteeProfileLatch, inviteeProfileTrigger] = latch();
-      invitee.services.ProfileService.SubscribeProfile().subscribe(inviteeProfile => {
+      invitee.services.ProfileService.subscribeProfile().subscribe(inviteeProfile => {
         if (inviteeProfile.profile?.username === 'test-user') {
           inviteeProfileTrigger();
         }

package/src/client/client.test.ts

@@ -309,8 +309,8 @@ describe('Client', () => {
       client.registerModel(TestModel);
 
       const party = client.echo.queryParties().first;
-      const selection = party.database.select(s => s.filter({ type: 'test' }).items);
-      await selection.update.waitForCondition(() => selection.getValue().length > 0);
+      const selection = party.database.select({ type: 'test' }).query();
+      await selection.update.waitForCondition(() => selection.result.length > 0);
 
       const item = selection.expectOne();
 

package/src/client/client.ts

@@ -169,8 +169,8 @@ export class Client {
     this._halo = new HaloProxy(this._serviceProvider);
     this._echo = new EchoProxy(this._serviceProvider);
 
-    this._halo._open();
-    this._echo._open();
+    await this._halo._open();
+    await this._echo._open();
 
     this._initialized = true; // TODO(burdon): Initialized === halo.initialized?
     clearInterval(timeout);
@@ -233,7 +233,7 @@ export class Client {
   //   Recreate echo instance? Big impact on hooks. Test.
   @synchronized
   async reset () {
-    await this.services.SystemService.Reset();
+    await this.services.SystemService.reset();
     this._initialized = false;
   }
 

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

@@ -0,0 +1,80 @@
+//
+// 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 }) => {
+        // If profile does not exist, send an empty array.
+        if (!this.echo.halo.isInitialized) {
+          next({ contacts: [] });
+        }
+
+        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,
@@ -37,7 +37,7 @@ class PartyService implements IPartyService {
 
   constructor (private echo: ECHO) {}
 
-  SubscribeToParty (request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
+  subscribeToParty (request: SubscribePartyRequest): Stream<SubscribePartyResponse> {
     const update = (next: (message: SubscribePartyResponse) => void) => {
       try {
         const party = this.echo.getParty(request.partyKey);
@@ -50,7 +50,7 @@ class PartyService implements IPartyService {
           }
         });
       } catch (error) {
-        if (error instanceof EchoNotOpenError) {
+        if (error instanceof InvalidStateError) {
           // Do nothing.
         } else {
           throw error;
@@ -83,7 +83,7 @@ class PartyService implements IPartyService {
     }
   }
 
-  SubscribeParties () {
+  subscribeParties () {
     return resultSetToStream(this.echo.queryParties(), (parties): SubscribePartiesResponse => {
       return ({
         parties: parties.map(party => ({
@@ -96,7 +96,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  async CreateParty () {
+  async createParty () {
     const party = await this.echo.createParty();
     return {
       publicKey: party.key,
@@ -105,7 +105,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  async CloneParty (snapshot: PartySnapshot): Promise<Party> {
+  async cloneParty (snapshot: PartySnapshot): Promise<Party> {
     const party = await this.echo.cloneParty(snapshot);
     return {
       publicKey: party.key,
@@ -114,7 +114,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  async SetPartyState (request: SetPartyStateRequest) {
+  async setPartyState (request: SetPartyStateRequest) {
     const party = this.echo.getParty(request.partyKey);
     if (!party) {
       throw new Error('Party not found');
@@ -144,7 +144,7 @@ class PartyService implements IPartyService {
     };
   }
 
-  CreateInvitation (request: CreateInvitationRequest): Stream<InvitationRequest> {
+  createInvitation (request: CreateInvitationRequest): Stream<InvitationRequest> {
     return new Stream(({ next, close }) => {
       const party = this.echo.getParty(request.partyKey) ?? raise(new PartyNotFoundError(request.partyKey));
       setImmediate(async () => {
@@ -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() });
@@ -185,7 +185,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  AcceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
+  acceptInvitation (request: InvitationDescriptorProto): Stream<RedeemedInvitation> {
     return new Stream(({ next, close }) => {
       const id = v4();
       const [secretLatch, secretTrigger] = latch();
@@ -221,7 +221,7 @@ class PartyService implements IPartyService {
     });
   }
 
-  async AuthenticateInvitation (request: AuthenticateInvitationRequest) {
+  async authenticateInvitation (request: AuthenticateInvitationRequest) {
     assert(request.processId, 'Process ID is missing.');
     const invitation = this.inviteeInvitations.get(request.processId);
     assert(invitation, 'Invitation not found.');
@@ -232,7 +232,7 @@ class PartyService implements IPartyService {
     invitation.secretTrigger?.();
   }
 
-  SubscribeMembers (request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
+  subscribeMembers (request: SubscribeMembersRequest): Stream<SubscribeMembersResponse> {
     const party = this.echo.getParty(request.partyKey);
     if (party) {
       return resultSetToStream(party.queryMembers(), (members): SubscribeMembersResponse => ({ members }));
@@ -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();