@dxos/echo-db 2.33.8-dev.8609bc45 → 2.33.9-dev.002e8917

package/src/pipeline/feed-muxer.ts

@@ -2,17 +2,16 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import { Message as HaloMessage } from '@dxos/credentials';
-import { keyToString } from '@dxos/crypto';
 import { checkType } from '@dxos/debug';
 import {
-  createFeedMeta, EchoEnvelope, FeedMessage, FeedStoreIterator, FeedWriter, IEchoStream, mapFeedWriter, Timeframe
+  createFeedMeta, EchoEnvelope, FeedMessage, FeedStoreIterator, FeedWriter, IEchoStream, mapFeedWriter
 } from '@dxos/echo-protocol';
-import { PublicKey } from '@dxos/protocols';
+import { PublicKey, Timeframe } from '@dxos/protocols';
 import { jsonReplacer } from '@dxos/util';
 
 import { EchoProcessor, TimeframeClock } from '../packlets/database';
@@ -139,7 +138,8 @@ export class FeedMuxer {
 
           if (message.echo) {
             const memberKey = this._partyProcessor.getFeedOwningMember(PublicKey.from(block.key));
-            assert(memberKey, `Ownership of feed ${keyToString(block.key)} could not be determined.`);
+            // TODO(wittjosiah): Is actually a Buffer for some reason. See todo in IFeedGenericBlock.
+            assert(memberKey, `Ownership of feed ${PublicKey.stringify(block.key as unknown as Buffer)} could not be determined.`);
 
             // Validate messge.
             const { itemId } = message.echo;

package/src/pipeline/message-selector.ts

@@ -2,15 +2,12 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
-import { getPartyCredentialMessageType, PartyCredential } from '@dxos/credentials';
 import { MessageSelector } from '@dxos/echo-protocol';
-import { PublicKey } from '@dxos/protocols';
 
 import { TimeframeClock } from '../packlets/database';
-import { PartyStateProvider } from './party-processor';
 
 const log = debug('dxos:echo-db:message-selector');
 
@@ -23,44 +20,16 @@ const log = debug('dxos:echo-db:message-selector');
  * @param partyProcessor
  * @param timeframeClock
  */
-export const createMessageSelector = (partyProcessor: PartyStateProvider, timeframeClock: TimeframeClock): MessageSelector => candidates => {
-  // Check ECHO message candidates first since they are less expensive than HALO cancidates.
+export const createMessageSelector = (timeframeClock: TimeframeClock): MessageSelector => candidates => {
+  // Pick the first candidate with a valid timeframe that has no gaps.
   for (let i = 0; i < candidates.length; i++) {
-    const { data: { timeframe, echo } } = candidates[i];
-    const feedKey = PublicKey.from(candidates[i].key);
-    if (!echo) {
-      continue;
-    }
-
-    assert(timeframe);
-    if (partyProcessor.isFeedAdmitted(feedKey) && !timeframeClock.hasGaps(timeframe)) {
-      return i;
-    }
-  }
-
-  // Check HALO message candidates.
-  for (let i = 0; i < candidates.length; i++) {
-    const { data: { timeframe, halo } } = candidates[i];
-    const feedKey = PublicKey.from(candidates[i].key);
-    if (!halo) {
-      continue;
-    }
+    const { data: { timeframe } } = candidates[i];
 
     assert(timeframe);
-    if (partyProcessor.isFeedAdmitted(feedKey) && !timeframeClock.hasGaps(timeframe)) {
+    if (!timeframeClock.hasGaps(timeframe)) {
       return i;
     }
-
-    if (partyProcessor.genesisRequired) {
-      try { // TODO(dmaretskyi): Get getPartyCredentialMessageType crashes for some reason.
-        // TODO(telackey): Add check that this is for the right Party.
-        if (getPartyCredentialMessageType(halo) === PartyCredential.Type.PARTY_GENESIS) {
-          return i;
-        }
-      } catch { }
-    }
   }
-
   // Not ready for this message yet.
   log('Skipping...');
 };

package/src/pipeline/metadata-store.ts

@@ -2,13 +2,13 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { synchronized } from '@dxos/async';
 import { failUndefined } from '@dxos/debug';
-import { EchoMetadata, PartyMetadata, schema, Timeframe } from '@dxos/echo-protocol';
-import { PublicKey } from '@dxos/protocols';
+import { EchoMetadata, PartyMetadata, schema } from '@dxos/echo-protocol';
+import { PublicKey, Timeframe } from '@dxos/protocols';
 import { Directory } from '@dxos/random-access-multi-storage';
 
 /**
@@ -20,13 +20,20 @@ export const STORAGE_VERSION = 1;
 
 const log = debug('dxos:snapshot-store');
 
+export interface AddPartyOptions {
+  key: PublicKey
+  genesisFeed: PublicKey
+}
+
+const emptyEchoMetadata = (): EchoMetadata => ({
+  version: STORAGE_VERSION,
+  parties: [],
+  created: new Date(),
+  updated: new Date()
+});
+
 export class MetadataStore {
-  private _metadata: EchoMetadata = {
-    version: STORAGE_VERSION,
-    parties: [],
-    created: new Date(),
-    updated: new Date()
-  };
+  private _metadata: EchoMetadata = emptyEchoMetadata();
 
   constructor (
     private readonly _directory: Directory
@@ -51,19 +58,26 @@ export class MetadataStore {
   async load (): Promise<void> {
     const file = this._directory.createOrOpen('EchoMetadata');
     try {
-      const { size } = await file.stat();
-      if (size === 0) {
+      const { size: fileLength } = await file.stat();
+      if (fileLength < 4) {
         return;
       }
+      // Loading file size from first 4 bytes.
+      const dataSize = fromBytesInt32(await file.read(0, 4));
+      log(`Load: data size ${dataSize}`);
+
+      // Sanity check.
+      {
+        if (fileLength < dataSize + 4) {
+          throw new Error('Metadata storage is corrupted');
+        }
+      }
 
-      const data = await file.read(0, size);
+      const data = await file.read(4, dataSize);
       this._metadata = schema.getCodecForType('dxos.echo.metadata.EchoMetadata').decode(data);
     } catch (err: any) {
-      if (err.code === 'ENOENT') {
-        return;
-      } else {
-        throw err;
-      }
+      log(`Error loading metadata: ${err}`);
+      this._metadata = emptyEchoMetadata();
     } finally {
       await file.close();
     }
@@ -82,22 +96,14 @@ export class MetadataStore {
 
     try {
       const encoded = Buffer.from(schema.getCodecForType('dxos.echo.metadata.EchoMetadata').encode(data));
-      await file.write(0, encoded);
 
-      // Truncate the rest of the file.
-      {
-        const { size } = await file.stat();
-        if (size > encoded.length) {
-          await file.truncate(encoded.length, size);
-        }
-      }
+      // Saving file size at first 4 bytes.
+      log(`Save: data size ${encoded.length}`);
+      await file.write(0, toBytesInt32(encoded.length));
+
+      // Saving data.
+      await file.write(4, encoded);
 
-      // Sanity check.
-      const { size } = await file.stat();
-      if (size !== encoded.length) {
-        console.log('SANITY!');
-      }
-      assert(size === encoded.length);
     } finally {
       await file.close();
     }
@@ -147,6 +153,14 @@ export class MetadataStore {
     await this._save();
   }
 
+  async setGenesisFeed (partyKey: PublicKey, feedKey: PublicKey): Promise<void> {
+    assert(PublicKey.isPublicKey(feedKey));
+    await this.addPartyFeed(partyKey, feedKey);
+    const party = this.getParty(partyKey) ?? failUndefined();
+    party.genesisFeedKey = feedKey;
+    await this._save();
+  }
+
   /**
    * Sets the data feed key in the party specified by public key and saves updated data in persistent storage.
    * Update party's feed list.
@@ -183,3 +197,11 @@ export class MetadataStore {
     await this._save();
   }
 }
+
+const toBytesInt32 = (num: number) => {
+  const buf = Buffer.alloc(4);
+  buf.writeInt32LE(num, 0);
+  return buf;
+};
+
+const fromBytesInt32 = (buf: Buffer) => buf.readInt32LE(0);

package/src/pipeline/party-feed-provider.ts

@@ -2,14 +2,14 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event, synchronized } from '@dxos/async';
 import { Keyring, KeyType } from '@dxos/credentials';
-import { FeedSelector, FeedStoreIterator, MessageSelector, Timeframe } from '@dxos/echo-protocol';
+import { FeedSelector, FeedStoreIterator, MessageSelector } from '@dxos/echo-protocol';
 import { FeedDescriptor, FeedStore } from '@dxos/feed-store';
-import { PublicKey } from '@dxos/protocols';
+import { PublicKey, Timeframe } from '@dxos/protocols';
 import { ComplexMap } from '@dxos/util';
 
 import { MetadataStore } from './metadata-store';

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

@@ -5,16 +5,16 @@
 import expect from 'expect';
 import { it as test } from 'mocha';
 
-import { promiseTimeout } from '@dxos/async';
+import { promiseTimeout, sleep } from '@dxos/async';
 import { createFeedAdmitMessage, createPartyGenesisMessage, Keyring, KeyType } from '@dxos/credentials';
 import { createId } from '@dxos/crypto';
 import { checkType } from '@dxos/debug';
-import { codec, FeedMessage, Timeframe } from '@dxos/echo-protocol';
+import { codec, FeedMessage } from '@dxos/echo-protocol';
 import { FeedStore } from '@dxos/feed-store';
 import { createTestProtocolPair } from '@dxos/mesh-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { ObjectModel } from '@dxos/object-model';
-import { PublicKey } from '@dxos/protocols';
+import { PublicKey, Timeframe } from '@dxos/protocols';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { afterTest } from '@dxos/testutils';
 
@@ -49,7 +49,7 @@ describe('PartyPipeline', () => {
     );
 
     const feed = await partyFeedProvider.createOrOpenWritableFeed();
-    await party.open({ feedHints: [feed.key] });
+    await party.open({ genesisFeedKey: feed.key });
     afterTest(async () => party.close());
 
     // PartyGenesis (self-signed by Party).
@@ -104,7 +104,7 @@ describe('PartyPipeline', () => {
     }
 
     await party.close();
-    await party.open({ feedHints: [feedKey] });
+    await party.open({ genesisFeedKey: feedKey });
 
     {
       await party.database.select().exec().update.waitFor(result => result.entities.length === 2);
@@ -132,7 +132,7 @@ describe('PartyPipeline', () => {
     expect(partyFeedProvider.getFeeds().find(k => k.key.equals(feedKey.publicKey))).toBeTruthy();
   });
 
-  test('opens feed from hints', async () => {
+  test('does not open unrelated feeds', async () => {
     const storage = createStorage('', StorageType.RAM);
     const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     afterTest(async () => feedStore.close());
@@ -158,21 +158,19 @@ describe('PartyPipeline', () => {
       PublicKey.random()
     );
 
-    await partyFeedProvider.createOrOpenWritableFeed();
+    const writeFeed = await partyFeedProvider.createOrOpenWritableFeed();
 
-    const feedOpened = feedStore.feedOpenedEvent.waitForCount(1);
-
-    await party.open({ feedHints: [otherFeedKey] });
+    await party.open({ genesisFeedKey: writeFeed.key });
     afterTest(async () => party.close());
 
-    await feedOpened;
+    // Wait for events to be processed.
+    await sleep(5);
 
-    expect(partyFeedProvider.getFeeds().some(k => k.key.equals(otherFeedKey))).toEqual(true);
+    expect(partyFeedProvider.getFeeds().some(k => k.key.equals(otherFeedKey))).toEqual(false);
   });
 
   test('manually create item', async () => {
     const { party, partyFeedProvider } = await setup();
-    await party.open();
 
     const feed = await partyFeedProvider.createOrOpenWritableFeed();
 
@@ -193,7 +191,6 @@ describe('PartyPipeline', () => {
 
   test('admit a second feed to the party', async () => {
     const { party, keyring, partyKey, feedStore } = await setup();
-    await party.open();
 
     const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
     const fullKey = keyring.getFullKey(feedKey.publicKey);
@@ -223,7 +220,6 @@ describe('PartyPipeline', () => {
 
   test('admit feed and then open it', async () => {
     const { party, keyring, partyKey, feedStore } = await setup();
-    await party.open();
 
     const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
     const fullKey = keyring.getFullKey(feedKey.publicKey);
@@ -270,7 +266,7 @@ describe('PartyPipeline', () => {
     expect(timeframe.isEmpty()).toBeFalsy();
 
     await party.close();
-    await party.open({ feedHints: [feedKey], targetTimeframe: timeframe });
+    await party.open({ genesisFeedKey: feedKey, targetTimeframe: timeframe });
   });
 
   test('two instances replicating', async () => {
@@ -304,9 +300,7 @@ describe('PartyPipeline', () => {
       [peer1.partyKey]
     ));
 
-    await party2.open({
-      feedHints: [peer1.feedKey]
-    });
+    await party2.open({ genesisFeedKey: peer1.feedKey });
     afterTest(async () => party2.close());
 
     createTestProtocolPair(

package/src/pipeline/party-pipeline.ts

@@ -2,14 +2,16 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'assert';
+import assert from 'node:assert';
 
 import { synchronized } from '@dxos/async';
 import { KeyType, Message as HaloMessage } from '@dxos/credentials';
 import { timed } from '@dxos/debug';
-import { createFeedWriter, DatabaseSnapshot, FeedSelector, FeedWriter, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
+import {
+  createFeedWriter, DatabaseSnapshot, FeedSelector, FeedWriter, PartyKey, PartySnapshot
+} from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
-import { PublicKey } from '@dxos/protocols';
+import { PublicKey, Timeframe } from '@dxos/protocols';
 import { SubscriptionGroup } from '@dxos/util';
 
 import { createMessageSelector, PartyProcessor, PartyFeedProvider, FeedMuxer } from '.';
@@ -30,9 +32,9 @@ export interface PipelineOptions {
 
 export interface OpenOptions {
   /**
-   * Keys of initial feeds needed to bootstrap the party.
+   * Initial feed that contains PartyGenesis message and acts as the root for the feed DAG.
    */
-  feedHints?: PublicKey[]
+  genesisFeedKey: PublicKey
   /**
    * Timeframe to start processing feed messages from.
    */
@@ -123,9 +125,9 @@ export class PartyPipeline {
    */
   @synchronized
   @timed(1_000)
-  async open (options: OpenOptions = {}) {
+  async open (options: OpenOptions) {
     const {
-      feedHints = [],
+      genesisFeedKey,
       initialTimeframe,
       targetTimeframe
     } = options;
@@ -147,17 +149,16 @@ export class PartyPipeline {
       void this._feedProvider.createOrOpenReadOnlyFeed(feed);
     }));
 
-    if (feedHints.length > 0) {
-      await this._partyProcessor.takeHints(feedHints.map(publicKey => ({ publicKey, type: KeyType.FEED })));
-    }
+    // TODO(dmaretskyi): We still need to hint at the genesis feed for some reason, not doing this breaks invitation tests.
+    await this._partyProcessor.takeHints([{ type: KeyType.FEED, publicKey: genesisFeedKey }]);
 
     //
     // Pipeline
     //
 
     const iterator = await this._feedProvider.createIterator(
-      createMessageSelector(this._partyProcessor, this._timeframeClock),
-      createFeedSelector(this._partyProcessor, feedHints),
+      createMessageSelector(this._timeframeClock),
+      createFeedSelector(this._partyProcessor, genesisFeedKey),
       initialTimeframe
     );
 
@@ -256,4 +257,4 @@ export class PartyPipeline {
   }
 }
 
-const createFeedSelector = (partyProcessor: PartyProcessor, hints: PublicKey[]): FeedSelector => feed => hints.some(hint => hint.equals(feed.key)) || partyProcessor.isFeedAdmitted(feed.key);
+const createFeedSelector = (partyProcessor: PartyProcessor, genesisFeed: PublicKey): FeedSelector => feed => genesisFeed.equals(feed.key) || partyProcessor.isFeedAdmitted(feed.key);

package/src/pipeline/party-processor.ts

@@ -2,8 +2,8 @@
 // Copyright 2020 DXOS.org
 //
 
-import assert from 'assert';
 import debug from 'debug';
+import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import {

package/src/protocol/authenticator.test.ts

@@ -5,21 +5,18 @@
 import expect from 'expect';
 import { it as test } from 'mocha';
 
-import { createAuthMessage, createKeyAdmitMessage, createPartyGenesisMessage, Keyring, KeyType } from '@dxos/credentials';
+import { createAuthMessage, createEnvelopeMessage, createFeedAdmitMessage, createKeyAdmitMessage, createPartyGenesisMessage, Keyring, KeyType, wrapMessage } from '@dxos/credentials';
 
 import { PartyProcessor } from '../pipeline';
 import { createAuthenticator } from './authenticator';
-import { CredentialsSigner } from './credentials-signer';
+import { createTestIdentityCredentials } from './identity-credentials';
 
 describe('authenticator', () => {
-  // TODO(dmaretskyi): Figure out how credentials work and if this test makes sense.
-  test.skip('authenticates admitted peer', async () => {
+  test('authenticates party creator', async () => {
     const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
     const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
-    const identityKey = await keyring.createKeyRecord({ type: KeyType.IDENTITY });
-    const deviceKey = await keyring.createKeyRecord({ type: KeyType.DEVICE });
-    const feedKey = await keyring.createKeyRecord({ type: KeyType.FEED });
-    const signer = CredentialsSigner.createDirectDeviceSigner(keyring);
+    const feedKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
 
     const partyProcessor = new PartyProcessor(partyKey.publicKey);
     await partyProcessor.processMessage({
@@ -27,16 +24,106 @@ describe('authenticator', () => {
         keyring,
         partyKey,
         feedKey.publicKey,
-        identityKey
+        partyKey
       ),
       meta: {} as any
     });
+    await partyProcessor.processMessage({
+      data: createEnvelopeMessage(
+        identity.keyring,
+        partyKey.publicKey,
+        wrapMessage(identity.identityGenesis),
+        [partyKey]
+      ),
+      meta: {} as any
+    });
+    await partyProcessor.processMessage({
+      data: createFeedAdmitMessage(
+        keyring,
+        partyKey.publicKey,
+        feedKey.publicKey,
+        [identity.deviceKeyChain]
+      ),
+      meta: {} as any
+    });
+
+    const authenticator = createAuthenticator(partyProcessor, identity.createCredentialsSigner(), null as any);
+
+    //
+    // This test follows the same party creation routing as party factory.
+    // Oddly, it does not admit the device key to the party.
+    // This means that authentication is actually done using the signature created using the feed key.
+    //
+
+    // Does not authenticate without the feed key.
+    {
+      const credential = createAuthMessage(
+        keyring,
+        partyKey.publicKey,
+        identity.identityKey,
+        identity.deviceKey
+      );
+      expect(await authenticator.authenticate(credential.payload)).toEqual(false);
+    }
+
+    // Does authenticate with the feed key.
+    {
+      const credential = createAuthMessage(
+        keyring,
+        partyKey.publicKey,
+        identity.identityKey,
+        identity.deviceKey,
+        feedKey.publicKey
+      );
+      expect(await authenticator.authenticate(credential.payload)).toEqual(true);
+    }
+  });
+
+  test('authenticates another identity', async () => {
+    const keyring = new Keyring();
+    const identity = await createTestIdentityCredentials(keyring);
+    const partyKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+    const feedKey = await keyring.createKeyRecord({ type: KeyType.PARTY });
+
+    const partyProcessor = new PartyProcessor(partyKey.publicKey);
+    await partyProcessor.processMessage({
+      data: createPartyGenesisMessage(
+        keyring,
+        partyKey,
+        feedKey.publicKey,
+        partyKey
+      ),
+      meta: {} as any
+    });
+    await partyProcessor.processMessage({
+      data: createEnvelopeMessage(
+        identity.keyring,
+        partyKey.publicKey,
+        wrapMessage(identity.identityGenesis),
+        [partyKey]
+      ),
+      meta: {} as any
+    });
+    await partyProcessor.processMessage({
+      data: createFeedAdmitMessage(
+        keyring,
+        partyKey.publicKey,
+        feedKey.publicKey,
+        [identity.deviceKeyChain]
+      ),
+      meta: {} as any
+    });
+
+    const authenticator = createAuthenticator(partyProcessor, identity.createCredentialsSigner(), null as any);
+
+    const identity2 = await createTestIdentityCredentials(keyring);
+
     await partyProcessor.processMessage({
       data: createKeyAdmitMessage(
         keyring,
         partyKey.publicKey,
-        identityKey,
-        [partyKey, identityKey]
+        identity2.identityKey,
+        [identity.deviceKeyChain]
       ),
       meta: {} as any
     });
@@ -44,20 +131,18 @@ describe('authenticator', () => {
       data: createKeyAdmitMessage(
         keyring,
         partyKey.publicKey,
-        deviceKey,
-        [identityKey, deviceKey]
+        identity2.deviceKey,
+        [identity.deviceKeyChain]
       ),
       meta: {} as any
     });
 
-    const authenticator = createAuthenticator(partyProcessor, signer, null as any);
     const credential = createAuthMessage(
       keyring,
       partyKey.publicKey,
-      identityKey,
-      deviceKey
+      identity2.identityKey,
+      identity2.deviceKey
     );
-
     expect(await authenticator.authenticate(credential.payload)).toEqual(true);
   });
 });

package/src/protocol/identity-credentials.ts

@@ -2,8 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-import { createIdentityInfoMessage, createKeyAdmitMessage, createPartyGenesisMessage, KeyChain, KeyRecord, Keyring, KeyType, SignedMessage } from '@dxos/credentials';
-import { humanize } from '@dxos/crypto';
+import {
+  createIdentityInfoMessage, createKeyAdmitMessage, createPartyGenesisMessage,
+  KeyChain, KeyRecord, Keyring, KeyType, SignedMessage
+} from '@dxos/credentials';
+import { humanize } from '@dxos/util';
 
 import { ContactManager, Preferences } from '../halo';
 import { CredentialsSigner } from './credentials-signer';

package/src/protocol/party-protocol-factory.ts

@@ -4,7 +4,7 @@
 
 import debug from 'debug';
 
-import { discoveryKey, keyToString } from '@dxos/crypto';
+import { discoveryKey } from '@dxos/crypto';
 import { PartyKey } from '@dxos/echo-protocol';
 import { Protocol } from '@dxos/mesh-protocol';
 import { MMSTTopology, NetworkManager, Plugin } from '@dxos/network-manager';
@@ -93,7 +93,7 @@ export class PartyProtocolFactory {
 
       userSession: {
         // TODO(burdon): See deprecated `protocolFactory` in HALO.
-        peerId: keyToString(this._peerId.asBuffer()),
+        peerId: this._peerId.toHex(),
         // TODO(telackey): This ought to be the CredentialsProvider itself, so that fresh credentials can be minted.
         credentials: this._credentials.get().toString('base64')
       },

package/src/protocol/replicator-plugin.ts

@@ -4,7 +4,6 @@
 
 import debug from 'debug';
 
-import { keyToString } from '@dxos/crypto';
 import { Replicator } from '@dxos/protocol-plugin-replicator';
 
 import { PartyFeedProvider } from '../pipeline';
@@ -18,7 +17,7 @@ export const createReplicatorPlugin = (feedProvider: PartyFeedProvider) =>
   new Replicator({
     load: async () => {
       const feeds = feedProvider.getFeeds();
-      log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
+      log(`Loading feeds: ${feeds.map(feed => feed.key.toHex())}`);
       return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
     },
 

package/src/snapshots/snapshot-generator.ts

@@ -4,7 +4,7 @@
 
 import debug from 'debug';
 
-import { humanize } from '@dxos/crypto';
+import { humanize } from '@dxos/util';
 
 import { TimeframeClock } from '../packlets/database';
 import { PartyPipeline } from '../pipeline';