@dxos/echo-db 2.33.5-dev.22471d71 → 2.33.5-dev.33d2877e

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

@@ -8,7 +8,8 @@ import { it as test } from 'mocha';
 import { promiseTimeout } from '@dxos/async';
 import { createFeedAdmitMessage, createPartyGenesisMessage, Keyring, KeyType } from '@dxos/credentials';
 import { createId, PublicKey } from '@dxos/crypto';
-import { codec, Timeframe } from '@dxos/echo-protocol';
+import { checkType } from '@dxos/debug';
+import { codec, FeedMessage, Timeframe } from '@dxos/echo-protocol';
 import { FeedStore } from '@dxos/feed-store';
 import { createTestProtocolPair } from '@dxos/mesh-protocol';
 import { ModelFactory } from '@dxos/model-factory';
@@ -24,15 +25,15 @@ import { PartyCore } from './party-core';
 describe('PartyCore', () => {
   const setup = async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     afterTest(async () => feedStore.close());
 
     const keyring = new Keyring();
 
-    const metadataStore = new MetadataStore(createStorage('metadata', StorageType.RAM));
+    const metadataStore = new MetadataStore(storage.directory('metadata'));
 
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
-    const snapshotStore = new SnapshotStore(createStorage('snapshots', StorageType.RAM));
+    const snapshotStore = new SnapshotStore(storage.directory('snapshots'));
 
     const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
 
@@ -51,7 +52,7 @@ describe('PartyCore', () => {
     afterTest(async () => party.close());
 
     // PartyGenesis (self-signed by Party).
-    await party.processor.writeHaloMessage(createPartyGenesisMessage(
+    await party.credentialsWriter.write(createPartyGenesisMessage(
       keyring,
       partyKey,
       feed.key,
@@ -59,7 +60,7 @@ describe('PartyCore', () => {
     );
 
     // FeedAdmit (signed by the Device KeyChain).
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       keyring,
       partyKey.publicKey,
       feed.key,
@@ -120,7 +121,7 @@ describe('PartyCore', () => {
     const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
 
     const eventFired = feedStore.feedOpenedEvent.waitForCount(1);
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       keyring,
       party.key,
       feedKey.publicKey,
@@ -132,15 +133,15 @@ describe('PartyCore', () => {
 
   test('opens feed from hints', async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     afterTest(async () => feedStore.close());
 
     const keyring = new Keyring();
 
-    const metadataStore = new MetadataStore(createStorage('metadata', StorageType.RAM));
+    const metadataStore = new MetadataStore(storage.directory('metadata'));
 
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
-    const snapshotStore = new SnapshotStore(createStorage('snapshots', StorageType.RAM));
+    const snapshotStore = new SnapshotStore(storage.directory('snapshots'));
 
     const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
 
@@ -160,7 +161,7 @@ describe('PartyCore', () => {
 
     const feedOpened = feedStore.feedOpenedEvent.waitForCount(1);
 
-    await party.open([{ type: KeyType.FEED, publicKey: otherFeedKey }]);
+    await party.open({ feedHints: [otherFeedKey] });
     afterTest(async () => party.close());
 
     await feedOpened;
@@ -175,16 +176,16 @@ describe('PartyCore', () => {
     const feed = await partyFeedProvider.createOrOpenWritableFeed();
 
     const itemId = createId();
-    await feed.feed.append({
+    await feed.feed.append(checkType<FeedMessage>({
+      timeframe: new Timeframe(),
       echo: {
         itemId,
         genesis: {
           itemType: 'dxos:example',
           modelType: ObjectModel.meta.type
-        },
-        timeframe: new Timeframe()
+        }
       }
-    });
+    }));
 
     await promiseTimeout(party.database.waitForItem({ id: itemId }), 1000, new Error('timeout'));
   });
@@ -197,7 +198,7 @@ describe('PartyCore', () => {
     const fullKey = keyring.getFullKey(feedKey.publicKey);
     const feed2 = await feedStore.openReadWriteFeed(fullKey!.publicKey, fullKey!.secretKey!);
 
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       keyring,
       party.key,
       feed2.key,
@@ -205,16 +206,16 @@ describe('PartyCore', () => {
     ));
 
     const itemId = createId();
-    await feed2.append({
+    await feed2.append(checkType<FeedMessage>({
+      timeframe: new Timeframe(),
       echo: {
         itemId,
         genesis: {
           itemType: 'dxos:example',
           modelType: ObjectModel.meta.type
-        },
-        timeframe: new Timeframe()
+        }
       }
-    });
+    }));
 
     await promiseTimeout(party.database.waitForItem({ id: itemId }), 1000, new Error('timeout'));
   });
@@ -226,7 +227,7 @@ describe('PartyCore', () => {
     const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
     const fullKey = keyring.getFullKey(feedKey.publicKey);
 
-    await party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await party.credentialsWriter.write(createFeedAdmitMessage(
       keyring,
       party.key,
       feedKey.publicKey,
@@ -235,16 +236,16 @@ describe('PartyCore', () => {
 
     const feed2 = await feedStore.openReadWriteFeed(fullKey!.publicKey, fullKey!.secretKey!);
     const itemId = createId();
-    await feed2.append({
+    await feed2.append(checkType<FeedMessage>({
+      timeframe: new Timeframe(),
       echo: {
         itemId,
         genesis: {
           itemType: 'dxos:example',
           modelType: ObjectModel.meta.type
-        },
-        timeframe: new Timeframe()
+        }
       }
-    });
+    }));
 
     await promiseTimeout(party.database.waitForItem({ id: itemId }), 1000, new Error('timeout'));
   });
@@ -253,13 +254,13 @@ describe('PartyCore', () => {
     const peer1 = await setup();
 
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     afterTest(async () => feedStore.close());
 
-    const metadataStore = new MetadataStore(createStorage('metadata', StorageType.RAM));
+    const metadataStore = new MetadataStore(storage.directory('metadata'));
 
     const modelFactory = new ModelFactory().registerModel(ObjectModel);
-    const snapshotStore = new SnapshotStore(createStorage('snapshots', StorageType.RAM));
+    const snapshotStore = new SnapshotStore(storage.directory('snapshots'));
 
     const partyFeedProvider = new PartyFeedProvider(metadataStore, peer1.keyring, feedStore, peer1.party.key);
 
@@ -273,17 +274,16 @@ describe('PartyCore', () => {
 
     const feed2 = await partyFeedProvider.createOrOpenWritableFeed();
 
-    await peer1.party.processor.writeHaloMessage(createFeedAdmitMessage(
+    await peer1.party.credentialsWriter.write(createFeedAdmitMessage(
       peer1.keyring,
       peer1.party.key,
       feed2.key,
       [peer1.partyKey]
     ));
 
-    await party2.open([{
-      publicKey: peer1.feedKey,
-      type: KeyType.FEED
-    }]);
+    await party2.open({
+      feedHints: [peer1.feedKey]
+    });
     afterTest(async () => party2.close());
 
     createTestProtocolPair(

package/src/pipeline/party-core.ts

@@ -5,15 +5,14 @@
 import assert from 'assert';
 
 import { synchronized } from '@dxos/async';
-import { KeyHint, KeyType } from '@dxos/credentials';
+import { KeyType, Message as HaloMessage } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { timed } from '@dxos/debug';
-import { createFeedWriter, DatabaseSnapshot, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
+import { createFeedWriter, DatabaseSnapshot, FeedWriter, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { SubscriptionGroup } from '@dxos/util';
 
-import { Database } from '../api';
-import { FeedDatabaseBackend, TimeframeClock } from '../database';
+import { Database, FeedDatabaseBackend, TimeframeClock } from '../packlets/database';
 import { createMessageSelector, PartyProcessor, PartyFeedProvider, Pipeline } from '../pipeline';
 import { createAutomaticSnapshots, SnapshotStore } from '../snapshots';
 
@@ -29,6 +28,22 @@ export interface PartyOptions {
   snapshotInterval?: number;
 }
 
+export interface OpenOptions {
+  /**
+   * Keys of initial feeds needed to bootstrap the party.
+   */
+  feedHints?: PublicKey[]
+  /**
+   * Timeframe to start processing feed messages from.
+   */
+  initialTimeframe?: Timeframe
+  /**
+   * Timeframe which must be reached until further processing.
+   * PartyCore.open will block until this timeframe is reached.
+   */
+  targetTimeframe?: Timeframe
+}
+
 /**
  * Encapsulates core components needed by a party:
  * - ECHO database with item-manager & item-demuxer.
@@ -56,7 +71,6 @@ export class PartyCore {
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
     private readonly _memberKey: PublicKey,
-    private readonly _initialTimeframe?: Timeframe,
     private readonly _options: PartyOptions = {}
   ) { }
 
@@ -99,17 +113,27 @@ export class PartyCore {
     return feed;
   }
 
+  get credentialsWriter (): FeedWriter<HaloMessage> {
+    assert(this._pipeline?.outboundHaloStream, 'Party not open');
+    return this._pipeline?.outboundHaloStream;
+  }
+
   /**
    * Opens the pipeline and connects the streams.
    */
   @synchronized
   @timed(1_000)
-  async open (keyHints: KeyHint[] = []) {
+  async open (options: OpenOptions = {}) {
+    const {
+      feedHints = [],
+      initialTimeframe
+    } = options;
+
     if (this.isOpen) {
       return this;
     }
 
-    this._timeframeClock = new TimeframeClock(this._initialTimeframe);
+    this._timeframeClock = new TimeframeClock(initialTimeframe);
 
     // Open all feeds known from metadata and open or create a writable feed to the party.
     await this._feedProvider.openKnownFeeds();
@@ -124,12 +148,8 @@ export class PartyCore {
       void this._feedProvider.createOrOpenReadOnlyFeed(feed);
     }));
 
-    // Hint at our own writable feed.
-    // TODO(dmaretskyi): Does not seem like it should be required, but without it replication between devices (B -> A) breaks.
-    await this._partyProcessor.takeHints([{ type: KeyType.FEED, publicKey: writableFeed.key }]);
-
-    if (keyHints.length > 0) {
-      await this._partyProcessor.takeHints(keyHints);
+    if (feedHints.length > 0) {
+      await this._partyProcessor.takeHints(feedHints.map(publicKey => ({ publicKey, type: KeyType.FEED })));
     }
 
     //
@@ -138,7 +158,7 @@ export class PartyCore {
 
     const iterator = await this._feedProvider.createIterator(
       createMessageSelector(this._partyProcessor, this._timeframeClock),
-      this._initialTimeframe
+      initialTimeframe
     );
 
     this._pipeline = new Pipeline(
@@ -147,11 +167,6 @@ export class PartyCore {
     // TODO(burdon): Support read-only parties.
     const [readStream, writeStream] = await this._pipeline.open();
 
-    // Must happen after open.
-    if (this._pipeline.outboundHaloStream) {
-      this._partyProcessor.setOutboundStream(this._pipeline.outboundHaloStream);
-    }
-
     //
     // Database
     //

package/src/pipeline/party-processor.ts

@@ -12,22 +12,40 @@ import {
   PartyState,
   Message as HaloMessage,
   IdentityEventType,
-  PartyEventType
+  PartyEventType,
+  SignedMessage
 } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-import { FeedKey, FeedWriter, IHaloStream, PartyKey, HaloStateSnapshot, WriteReceipt } from '@dxos/echo-protocol';
+import { FeedKey, IHaloStream, PartyKey, HaloStateSnapshot } from '@dxos/echo-protocol';
 import { jsonReplacer } from '@dxos/util';
 
 const log = debug('dxos:echo-db:party-processor');
 
+export interface CredentialProcessor {
+  processMessage (message: IHaloStream): Promise<void>
+}
+
+export interface PartyStateProvider {
+  partyKey: PublicKey
+
+  /**
+   * Whether PartyGenesis was already processed.
+   */
+  genesisRequired: boolean
+  memberKeys: PublicKey[]
+  feedKeys: PublicKey[]
+  getFeedOwningMember (feedKey: FeedKey): PublicKey | undefined
+  isFeedAdmitted (feedKey: FeedKey): boolean
+
+  getOfflineInvitation (invitationID: Buffer): SignedMessage | undefined
+}
+
 /**
  * TODO(burdon): Wrapper/Bridge between HALO APIs.
  */
-export class PartyProcessor {
+export class PartyProcessor implements CredentialProcessor, PartyStateProvider {
   private readonly _state: PartyState;
 
-  private _outboundHaloStream: FeedWriter<HaloMessage> | undefined;
-
   readonly feedAdded = new Event<FeedKey>()
 
   public readonly keyOrInfoAdded = new Event<PublicKey>();
@@ -124,16 +142,6 @@ export class PartyProcessor {
     await this._state.processMessages([data]);
   }
 
-  setOutboundStream (stream: FeedWriter<HaloMessage>) {
-    this._outboundHaloStream = stream;
-  }
-
-  async writeHaloMessage (message: HaloMessage): Promise<WriteReceipt> {
-    assert(this._outboundHaloStream, 'Party is closed or read-only');
-    // TODO(marik-d): Wait for the message to be processed?
-    return this._outboundHaloStream.write(message);
-  }
-
   makeSnapshot (): HaloStateSnapshot {
     return {
       messages: this._haloMessages

package/src/pipeline/pipeline.test.ts

@@ -15,7 +15,7 @@ import { createSetPropertyMutation } from '@dxos/model-factory';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { jsonReplacer } from '@dxos/util';
 
-import { TimeframeClock } from '../database';
+import { TimeframeClock } from '../packlets/database';
 import { PartyProcessor } from './party-processor';
 import { Pipeline } from './pipeline';
 
@@ -25,7 +25,7 @@ const log = debug('dxos:echo:pipeline:test');
 describe('pipeline', () => {
   test('streams', async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const feedKeys: Uint8Array[] = [];
     const feedSelector: FeedSelector = descriptor => !!feedKeys.find(key => descriptor.key.equals(key));
     const feedReadStream = new FeedStoreIterator(feedSelector, () => 0, new Timeframe());
@@ -87,7 +87,7 @@ describe('pipeline', () => {
 
   test('writing', async () => {
     const storage = createStorage('', StorageType.RAM);
-    const feedStore = new FeedStore(storage, { valueEncoding: codec });
+    const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const feedReadStream = new FeedStoreIterator(() => true, () => 0, new Timeframe());
 
     const { publicKey, secretKey } = createKeyPair();
@@ -133,8 +133,7 @@ describe('pipeline', () => {
       itemId: '123',
       genesis: {
         itemType: 'foo'
-      },
-      timeframe: expect.any(Timeframe)
+      }
     });
   });
 });

package/src/pipeline/pipeline.ts

@@ -16,8 +16,8 @@ import {
 import { createReadable } from '@dxos/feed-store';
 import { jsonReplacer } from '@dxos/util';
 
-import { TimeframeClock } from '../database';
-import { PartyProcessor } from './party-processor';
+import { TimeframeClock } from '../packlets/database';
+import { CredentialProcessor, PartyStateProvider } from './party-processor';
 
 interface Options {
   readLogger?: (msg: any) => void
@@ -55,17 +55,13 @@ export class Pipeline {
    * @param _options
    */
   constructor (
-    private readonly _partyProcessor: PartyProcessor,
+    private readonly _partyProcessor: CredentialProcessor & PartyStateProvider,
     private readonly _feedStorIterator: FeedStoreIterator,
     private readonly _timeframeClock: TimeframeClock,
     private readonly _feedWriter?: FeedWriter<FeedMessage>,
     private readonly _options: Options = {}
   ) {}
 
-  get partyKey () {
-    return this._partyProcessor.partyKey;
-  }
-
   get isOpen () {
     return this._inboundEchoStream !== undefined;
   }
@@ -113,6 +109,8 @@ export class Pipeline {
         try {
           const { data: message } = block;
 
+          this._timeframeClock.updateTimeframe(PublicKey.from(block.key), block.seq);
+
           //
           // HALO
           //
@@ -129,7 +127,6 @@ export class Pipeline {
           //
 
           if (message.echo) {
-            this._timeframeClock.updateTimeframe(PublicKey.from(block.key), block.seq);
             const memberKey = this._partyProcessor.getFeedOwningMember(PublicKey.from(block.key));
             assert(memberKey, `Ownership of feed ${keyToString(block.key)} could not be determined.`);
 
@@ -142,7 +139,7 @@ export class Pipeline {
                   seq: block.seq,
                   feedKey: block.key,
                   memberKey,
-                  timeframe: message.echo.timeframe ?? new Timeframe()
+                  timeframe: message.timeframe ?? new Timeframe()
                 },
                 data: message.echo
               }));
@@ -171,13 +168,13 @@ export class Pipeline {
       }, this._feedWriter);
 
       this._outboundEchoStream = mapFeedWriter<EchoEnvelope, FeedMessage>(async message => ({
-        echo: {
-          ...message,
-          timeframe: this._timeframeClock.timeframe
-        }
+        timeframe: this._timeframeClock.timeframe,
+        echo: message
+      }), loggingWriter);
+      this._outboundHaloStream = mapFeedWriter<HaloMessage, FeedMessage>(async message => ({
+        timeframe: this._timeframeClock.timeframe,
+        halo: message
       }), loggingWriter);
-      this._outboundHaloStream =
-        mapFeedWriter<HaloMessage, FeedMessage>(async message => ({ halo: message }), loggingWriter);
     }
 
     return [

package/src/protocol/auth-plugin.ts

@@ -9,6 +9,4 @@ import { Replicator } from '@dxos/protocol-plugin-replicator';
 /**
  * Creates authenticator network-protocol plugin that guards access to the replicator.
  */
-export function createAuthPlugin (authenticator: Authenticator, peerId: PublicKey) {
-  return new AuthPlugin(peerId.asBuffer(), authenticator, [Replicator.extension]);
-}
+export const createAuthPlugin = (authenticator: Authenticator, peerId: PublicKey) => new AuthPlugin(peerId.asBuffer(), authenticator, [Replicator.extension]);

package/src/protocol/authenticator.test.ts

@@ -6,7 +6,6 @@ import expect from 'expect';
 import { it as test } from 'mocha';
 
 import { createAuthMessage, createKeyAdmitMessage, createPartyGenesisMessage, Keyring, KeyType } from '@dxos/credentials';
-import { MockFeedWriter } from '@dxos/echo-protocol';
 
 import { PartyProcessor } from '../pipeline';
 import { createAuthenticator } from './authenticator';
@@ -23,8 +22,6 @@ describe('authenticator', () => {
     const signer = CredentialsSigner.createDirectDeviceSigner(keyring);
 
     const partyProcessor = new PartyProcessor(partyKey.publicKey);
-    const feed = new MockFeedWriter();
-    partyProcessor.setOutboundStream(feed);
     await partyProcessor.processMessage({
       data: createPartyGenesisMessage(
         keyring,
@@ -53,7 +50,7 @@ describe('authenticator', () => {
       meta: {} as any
     });
 
-    const authenticator = createAuthenticator(partyProcessor, signer);
+    const authenticator = createAuthenticator(partyProcessor, signer, null as any);
     const credential = createAuthMessage(
       keyring,
       partyKey.publicKey,

package/src/protocol/authenticator.ts

@@ -4,27 +4,29 @@
 
 import debug from 'debug';
 
-import { Authenticator, codec, createAuthMessage, createEnvelopeMessage, createFeedAdmitMessage, PartyAuthenticator } from '@dxos/credentials';
-import { FeedKey, PartyKey } from '@dxos/echo-protocol';
+import { Message as HaloMessage, Authenticator, codec, createAuthMessage, createEnvelopeMessage, createFeedAdmitMessage, PartyAuthenticator } from '@dxos/credentials';
+import { FeedKey, FeedWriter, PartyKey } from '@dxos/echo-protocol';
 
 import { PartyProcessor } from '../pipeline';
 import { CredentialsSigner } from './credentials-signer';
 
 const log = debug('dxos:echo-db:authenticator');
 
-export function createAuthenticator (partyProcessor: PartyProcessor, credentialsSigner: CredentialsSigner): Authenticator {
-  return new PartyAuthenticator(partyProcessor.state, async auth => {
-    if (auth.feedAdmit && auth.feedKey && !partyProcessor.isFeedAdmitted(auth.feedKey)) {
-      log(`Admitting feed of authenticated member: ${auth.feedKey}`);
-      await partyProcessor.writeHaloMessage(createEnvelopeMessage(
-        credentialsSigner.signer,
-        partyProcessor.partyKey,
-        auth.feedAdmit,
-        [credentialsSigner.getDeviceSigningKeys()]
-      ));
-    }
-  });
-}
+export const createAuthenticator = (
+  partyProcessor: PartyProcessor,
+  credentialsSigner: CredentialsSigner,
+  credentialsWriter: FeedWriter<HaloMessage>
+): Authenticator => new PartyAuthenticator(partyProcessor.state, async auth => {
+  if (auth.feedAdmit && auth.feedKey && !partyProcessor.isFeedAdmitted(auth.feedKey)) {
+    log(`Admitting feed of authenticated member: ${auth.feedKey}`);
+    await credentialsWriter.write(createEnvelopeMessage(
+      credentialsSigner.signer,
+      partyProcessor.partyKey,
+      auth.feedAdmit,
+      [credentialsSigner.getDeviceSigningKeys()]
+    ));
+  }
+});
 
 export interface CredentialsProvider {
   /**
@@ -33,24 +35,22 @@ export interface CredentialsProvider {
   get (): Buffer
 }
 
-export function createCredentialsProvider (credentialsSigner: CredentialsSigner, partyKey: PartyKey, feedKey: FeedKey): CredentialsProvider {
-  return {
-    get: () => {
-      const authMessage = createAuthMessage(
+export const createCredentialsProvider = (credentialsSigner: CredentialsSigner, partyKey: PartyKey, feedKey: FeedKey): CredentialsProvider => ({
+  get: () => {
+    const authMessage = createAuthMessage(
+      credentialsSigner.signer,
+      partyKey,
+      credentialsSigner.getIdentityKey(),
+      credentialsSigner.getDeviceSigningKeys(),
+      feedKey,
+      undefined,
+      createFeedAdmitMessage(
         credentialsSigner.signer,
         partyKey,
-        credentialsSigner.getIdentityKey(),
-        credentialsSigner.getDeviceSigningKeys(),
         feedKey,
-        undefined,
-        createFeedAdmitMessage(
-          credentialsSigner.signer,
-          partyKey,
-          feedKey,
-          [feedKey, credentialsSigner.getDeviceSigningKeys()]
-        )
-      );
-      return Buffer.from(codec.encode(authMessage));
-    }
-  };
-}
+        [feedKey, credentialsSigner.getDeviceSigningKeys()]
+      )
+    );
+    return Buffer.from(codec.encode(authMessage));
+  }
+});

package/src/protocol/halo-recovery-plugin.ts

@@ -12,9 +12,7 @@ import { HaloRecoveryInitiator, InvitationFactory } from '../invitations';
  * Plugin is intended to be used in HALO party swarm.
  *
  */
-export function createHaloRecoveryPlugin (identityKey: PublicKey, invitationFactory: InvitationFactory, peerId: PublicKey) {
-  return new GreetingCommandPlugin(
-    peerId.asBuffer(),
-    HaloRecoveryInitiator.createHaloInvitationClaimHandler(identityKey, invitationFactory)
-  );
-}
+export const createHaloRecoveryPlugin = (identityKey: PublicKey, invitationFactory: InvitationFactory, peerId: PublicKey) => new GreetingCommandPlugin(
+  peerId.asBuffer(),
+  HaloRecoveryInitiator.createHaloInvitationClaimHandler(identityKey, invitationFactory)
+);

package/src/protocol/identity-credentials.ts

@@ -25,7 +25,7 @@ export interface IdentityCredentials {
 
 export type IdentityCredentialsProvider = () => IdentityCredentials | undefined
 
-export async function createTestIdentityCredentials (keyring: Keyring): Promise<IdentityCredentials> {
+export const createTestIdentityCredentials = async (keyring: Keyring): Promise<IdentityCredentials> => {
   const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
   const deviceKey = await keyring.createKeyRecord({ type: KeyType.DEVICE });
   const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
@@ -53,9 +53,9 @@ export async function createTestIdentityCredentials (keyring: Keyring): Promise<
     preferences: undefined,
     contacts: undefined
   };
-}
+};
 
-export async function deriveTestDeviceCredentials (identity: IdentityCredentials): Promise<IdentityCredentials> {
+export const deriveTestDeviceCredentials = async (identity: IdentityCredentials): Promise<IdentityCredentials> => {
   const deviceKey = await identity.keyring.createKeyRecord({ type: KeyType.DEVICE });
   const keyAdmit = createKeyAdmitMessage(identity.keyring, identity.identityKey.publicKey, deviceKey, [identity.identityKey]);
 
@@ -75,4 +75,4 @@ export async function deriveTestDeviceCredentials (identity: IdentityCredentials
       deviceKeyChain
     )
   };
-}
+};

package/src/protocol/offline-invitation-plugin.ts

@@ -11,9 +11,7 @@ import { InvitationFactory, OfflineInvitationClaimer } from '../invitations';
  * Creates network protocol plugin that allows peers to claim offline invitations.
  * Plugin is intended to be used in data-party swarms.
  */
-export function createOfflineInvitationPlugin (invitationFactory: InvitationFactory, peerId: PublicKey) {
-  return new GreetingCommandPlugin(
-    peerId.asBuffer(),
-    OfflineInvitationClaimer.createOfflineInvitationClaimHandler(invitationFactory)
-  );
-}
+export const createOfflineInvitationPlugin = (invitationFactory: InvitationFactory, peerId: PublicKey) => new GreetingCommandPlugin(
+  peerId.asBuffer(),
+  OfflineInvitationClaimer.createOfflineInvitationClaimHandler(invitationFactory)
+);