@dxos/echo-db 2.33.3-dev.5c4af82a → 2.33.3

package/src/protocol/identity-credentials.ts

@@ -0,0 +1,78 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { createIdentityInfoMessage, createKeyAdmitMessage, createPartyGenesisMessage, KeyChain, KeyRecord, Keyring, KeyType, SignedMessage } from '@dxos/credentials';
+
+import { ContactManager, Preferences } from '../halo';
+import { CredentialsSigner } from './credentials-signer';
+
+/**
+ * Provides access to identity credentials without revealing the underlying mechanism (HALO party).
+ */
+export interface IdentityCredentials {
+  keyring: Keyring
+  identityKey: KeyRecord
+  deviceKey: KeyRecord
+  deviceKeyChain: KeyChain
+  identityGenesis: SignedMessage
+  identityInfo: SignedMessage | undefined
+  displayName: string | undefined
+  createCredentialsSigner(): CredentialsSigner
+  preferences: Preferences | undefined
+  contacts: ContactManager | undefined
+}
+
+export type IdentityCredentialsProvider = () => IdentityCredentials | undefined
+
+export async function createTestIdentityCredentials (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 });
+
+  const partyGenesis = createPartyGenesisMessage(keyring, identityKey, feedKey.publicKey, deviceKey);
+  const keyAdmit = createKeyAdmitMessage(keyring, identityKey.publicKey, identityKey);
+
+  const messageMap = new Map();
+  messageMap.set(identityKey.publicKey.toHex(), keyAdmit);
+  messageMap.set(deviceKey.publicKey.toHex(), partyGenesis);
+  const deviceKeyChain = Keyring.buildKeyChain(deviceKey.publicKey, messageMap, [feedKey.publicKey]);
+
+  const displayName = identityKey.publicKey.humanize();
+  const identityInfo = createIdentityInfoMessage(keyring, displayName, identityKey);
+
+  return {
+    keyring,
+    identityKey,
+    deviceKey,
+    deviceKeyChain,
+    identityGenesis: keyAdmit.payload as SignedMessage,
+    identityInfo: identityInfo.payload as SignedMessage,
+    displayName,
+    createCredentialsSigner: () => new CredentialsSigner(keyring, identityKey, deviceKey, deviceKeyChain),
+    preferences: undefined,
+    contacts: undefined
+  };
+}
+
+export async function deriveTestDeviceCredentials (identity: IdentityCredentials): Promise<IdentityCredentials> {
+  const deviceKey = await identity.keyring.createKeyRecord({ type: KeyType.DEVICE });
+  const keyAdmit = createKeyAdmitMessage(identity.keyring, identity.identityKey.publicKey, deviceKey, [identity.identityKey]);
+
+  const messageMap = new Map();
+  messageMap.set(identity.identityKey.publicKey.toHex(), identity.identityGenesis);
+  messageMap.set(deviceKey.publicKey.toHex(), keyAdmit);
+  const deviceKeyChain = Keyring.buildKeyChain(deviceKey.publicKey, messageMap, []);
+
+  return {
+    ...identity,
+    deviceKey,
+    deviceKeyChain,
+    createCredentialsSigner: () => new CredentialsSigner(
+      identity.keyring,
+      identity.identityKey,
+      deviceKey,
+      deviceKeyChain
+    )
+  };
+}

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

@@ -6,7 +6,7 @@ import debug from 'debug';
 
 import { synchronized } from '@dxos/async';
 import { discoveryKey, keyToString, PublicKey } from '@dxos/crypto';
-import { FeedKey, FeedSetProvider, PartyKey } from '@dxos/echo-protocol';
+import { FeedKey, PartyKey } from '@dxos/echo-protocol';
 import type { HypercoreFeed } from '@dxos/feed-store';
 import { Protocol } from '@dxos/mesh-protocol';
 import { MMSTTopology, NetworkManager, Plugin } from '@dxos/network-manager';
@@ -32,12 +32,11 @@ export class PartyProtocolFactory {
     private readonly _networkManager: NetworkManager,
     private readonly _feedProvider: PartyFeedProvider,
     private readonly _peerId: PublicKey,
-    private readonly _credentials: CredentialsProvider,
-    activeFeeds: FeedSetProvider
+    private readonly _credentials: CredentialsProvider
   ) {
     // Replication.
     this._replicatorProtocolPluginFactory =
-      new ReplicatorProtocolPluginFactory(this._feedProvider, activeFeeds);
+      new ReplicatorProtocolPluginFactory(this._feedProvider);
   }
 
   async start (plugins: Plugin[]) {
@@ -125,34 +124,31 @@ export class PartyProtocolFactory {
  */
 export class ReplicatorProtocolPluginFactory {
   constructor (
-    private readonly _feedProvider: PartyFeedProvider,
-    private readonly _activeFeeds: FeedSetProvider
+    private readonly _feedProvider: PartyFeedProvider
   ) {}
 
   createPlugins () {
     return [
       new Replicator({
         load: async () => {
-          const partyFeeds = await Promise.all(this._activeFeeds.get().map(feedKey => this._openFeed(feedKey)));
-          log(`Loading feeds: ${partyFeeds.map(feed => keyToString(feed.key))}`);
-          return partyFeeds.map((feed) => {
-            return { discoveryKey: feed.discoveryKey };
-          });
+          const feeds = this._feedProvider.getFeeds();
+          log(`Loading feeds: ${feeds.map(feed => keyToString(feed.key))}`);
+          return feeds.map((feed) => ({ discoveryKey: feed.feed.discoveryKey }));
         },
 
         subscribe: (addFeedToReplicatedSet: (feed: any) => void) => {
-          return this._activeFeeds.added.on(async (feedKey) => {
-            log(`Adding feed: ${feedKey.toHex()}`);
-            const feed = await this._openFeed(feedKey);
-            addFeedToReplicatedSet({ discoveryKey: feed.discoveryKey });
+          return this._feedProvider.feedOpened.on(async (feed) => {
+            log(`Adding feed: ${feed.key.toHex()}`);
+            addFeedToReplicatedSet({ discoveryKey: feed.feed.discoveryKey });
           });
         },
 
         replicate: async (remoteFeeds, info) => {
           // We can ignore remoteFeeds entirely, since the set of feeds we want to replicate is dictated by the Party.
           // TODO(telackey): Why are we opening feeds? Necessary or belt/braces thinking, or because open party does it?
-          log(`Replicating: peerId=${info.session}; feeds=${this._activeFeeds.get().map(key => key.toHex())}`);
-          return Promise.all(this._activeFeeds.get().map(feedKey => this._openFeed(feedKey)));
+          const feeds = this._feedProvider.getFeeds();
+          log(`Replicating: peerId=${info.session}; feeds=${feeds.map(feed => feed.key.toHex())}`);
+          return feeds.map(feed => feed.feed);
         }
       })
     ];

package/src/snapshots/snapshot-store.ts

@@ -4,7 +4,6 @@
 
 import assert from 'assert';
 import debug from 'debug';
-import pify from 'pify';
 
 import { keyToString } from '@dxos/crypto';
 import { schema, PartyKey, PartySnapshot } from '@dxos/echo-protocol';
@@ -26,12 +25,12 @@ export class SnapshotStore {
     const file = this._storage.createOrOpen(partyKey.toHex());
 
     try {
-      const { size } = await pify(file.stat.bind(file))();
+      const { size } = await file.stat();
       if (size === 0) {
         return undefined;
       }
 
-      const data = await pify(file.read.bind(file))(0, size);
+      const data = await file.read(0, size);
       return schema.getCodecForType('dxos.echo.snapshot.PartySnapshot').decode(data);
     } catch (err: any) {
       if (err.code === 'ENOENT') {
@@ -40,7 +39,7 @@ export class SnapshotStore {
         throw err;
       }
     } finally {
-      await pify(file.close.bind(file))();
+      await file.close();
     }
   }
 
@@ -50,9 +49,9 @@ export class SnapshotStore {
 
     try {
       const data = schema.getCodecForType('dxos.echo.snapshot.PartySnapshot').encode(snapshot);
-      await pify(file.write.bind(file))(0, Buffer.from(data));
+      await file.write(0, Buffer.from(data));
     } finally {
-      await pify(file.close.bind(file))();
+      await file.close();
     }
   }