@dxos/client-services 0.1.22 → 0.1.24-next.6b1f434

package/src/packlets/deprecated/space.ts

@@ -4,7 +4,6 @@
 
 import assert from 'node:assert';
 
-import { EventSubscriptions } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { todo } from '@dxos/debug';
 import { log } from '@dxos/log';
@@ -94,29 +93,29 @@ export class SpaceServiceImpl implements SpaceService {
   }
 
   subscribeSpaces() {
-    return new Stream<SubscribeSpacesResponse>(({ next }) => {
-      const subscriptions = new EventSubscriptions();
-
+    return new Stream<SubscribeSpacesResponse>(({ next, ctx }) => {
       const onUpdate = () => {
-        const spaces = Array.from(this.serviceContext.dataSpaceManager!.spaces.values()).map(
-          (space): Space => ({
-            publicKey: space.key,
-            isOpen: true,
-            isActive: true,
-            members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
-              identityKey: member.key,
-              profile: {
+        const spaces = Array.from(this.serviceContext.dataSpaceManager!.spaces.values())
+          .filter((space) => this.serviceContext.dataServiceSubscriptions.getDataService(space.key)) // Skip spaces without data service available.
+          .map(
+            (space): Space => ({
+              publicKey: space.key,
+              isOpen: true,
+              isActive: true,
+              members: Array.from(space.inner.spaceState.members.values()).map((member) => ({
                 identityKey: member.key,
-                displayName: member.assertion.profile?.displayName ?? humanize(member.key)
-              },
-              presence:
-                this.serviceContext.identityManager.identity?.identityKey.equals(member.key) ||
-                space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key)).length > 0
-                  ? SpaceMember.PresenceState.ONLINE
-                  : SpaceMember.PresenceState.OFFLINE
-            }))
-          })
-        );
+                profile: {
+                  identityKey: member.key,
+                  displayName: member.assertion.profile?.displayName ?? humanize(member.key)
+                },
+                presence:
+                  this.serviceContext.identityManager.identity?.identityKey.equals(member.key) ||
+                  space.presence.getPeersOnline().filter(({ identityKey }) => identityKey.equals(member.key)).length > 0
+                    ? SpaceMember.PresenceState.ONLINE
+                    : SpaceMember.PresenceState.OFFLINE
+              }))
+            })
+          );
         log('update', { spaces });
         next({ spaces });
       };
@@ -128,25 +127,27 @@ export class SpaceServiceImpl implements SpaceService {
 
         await this.serviceContext.initialized.wait();
 
-        subscriptions.add(
-          this.serviceContext.dataSpaceManager!.updated.on(() => {
-            this.serviceContext.dataSpaceManager!.spaces.forEach((space) => {
-              subscriptions.add(space.stateUpdate.on(onUpdate));
-              subscriptions.add(space.presence.updated.on(onUpdate));
-            });
-            onUpdate();
-          })
-        );
-
-        this.serviceContext.dataSpaceManager!.spaces.forEach((space) => {
-          subscriptions.add(space.stateUpdate.on(onUpdate));
-          subscriptions.add(space.presence.updated.on(onUpdate));
+        // TODO(dmaretskyi): Create a pattern for subscribing to a set of objects.
+        const subscribeSpaces = () => {
+          for (const space of this.serviceContext.dataSpaceManager!.spaces.values()) {
+            if (!this.serviceContext.dataServiceSubscriptions.getDataService(space.key)) {
+              // Skip spaces without data service available.
+              continue;
+            }
+
+            space.stateUpdate.on(ctx, onUpdate);
+            space.presence.updated.on(ctx, onUpdate);
+          }
+        };
+
+        this.serviceContext.dataSpaceManager!.updated.on(ctx, () => {
+          subscribeSpaces();
+          onUpdate();
         });
 
+        subscribeSpaces();
         onUpdate();
       });
-
-      return () => subscriptions.clear();
     });
   }
 
@@ -159,6 +160,9 @@ export class SpaceServiceImpl implements SpaceService {
   }
 
   async createSpace(): Promise<Space> {
+    if (!this.serviceContext.identityManager.identity) {
+      throw new Error('This device has no HALO identity available. See https://docs.dxos.org/guide/halo');
+    }
     await this.serviceContext.initialized.wait();
     const space = await this.serviceContext.dataSpaceManager!.createSpace();
     return {

package/src/packlets/deprecated/system.ts

@@ -3,33 +3,46 @@
 //
 
 import { Config } from '@dxos/config';
-import { SystemService } from '@dxos/protocols/proto/dxos/client';
+import { StatusResponse, SystemService } from '@dxos/protocols/proto/dxos/client';
+import { MaybePromise } from '@dxos/util';
 
-import { ServiceContext } from '../services';
+export type SystemServiceOptions = {
+  config: Config;
+  onInit: () => MaybePromise<void>;
+  onStatus: () => MaybePromise<StatusResponse>;
+  onReset: () => MaybePromise<void>;
+};
 
 /**
  * @deprecated
  */
 export class SystemServiceImpl implements SystemService {
-  constructor(private readonly _config: Config, private readonly _serviceContext: ServiceContext) {}
+  private readonly _config: Config;
+  private readonly _onInit: () => MaybePromise<void>;
+  private readonly _onStatus: () => MaybePromise<StatusResponse>;
+  private readonly _onReset: () => MaybePromise<void>;
 
-  // TODO(burdon): Remove.
-  async initSession() {
-    // Ok.
+  constructor({ config, onInit, onStatus, onReset }: SystemServiceOptions) {
+    this._config = config;
+    this._onInit = onInit;
+    this._onStatus = onStatus;
+    this._onReset = onReset;
   }
 
-  async getConfig(request: void) {
+  async getConfig() {
     return this._config.values;
   }
 
   // TODO(burdon): Connect to iframe RPC heartbeat for network status?
-  async getStatus(request: void) {
-    return {
-      message: `ok: ${Date.now()}`
-    };
+  async getStatus() {
+    return this._onStatus();
+  }
+
+  async initSession() {
+    await this._onInit();
   }
 
-  async reset(request: any) {
-    await this._serviceContext.reset();
+  async reset() {
+    await this._onReset();
   }
 }

package/src/packlets/devtools/devtools.ts

@@ -33,14 +33,14 @@ import {
   SubscribeToSpacesRequest,
   SubscribeToSpacesResponse,
   SubscribeToSignalStatusResponse,
-  SubscribeToSignalTraceResponse,
+  SignalResponse,
   SubscribeToSwarmInfoResponse
 } from '@dxos/protocols/proto/dxos/devtools/host';
 
 import { ServiceContext } from '../services';
 import { subscribeToFeedBlocks, subscribeToFeeds } from './feeds';
 import { subscribeToKeyringKeys } from './keys';
-import { subscribeToNetworkStatus, subscribeToSignalTrace, subscribeToSwarmInfo } from './network';
+import { subscribeToNetworkStatus, subscribeToSignal, subscribeToSwarmInfo } from './network';
 import { subscribeToSpaces } from './spaces';
 
 export class DevtoolsHostEvents {
@@ -133,8 +133,8 @@ export class DevtoolsServiceImpl implements DevtoolsHost {
     return subscribeToNetworkStatus({ networkManager: this.params.context.networkManager });
   }
 
-  subscribeToSignalTrace(): Stream<SubscribeToSignalTraceResponse> {
-    return subscribeToSignalTrace({ networkManager: this.params.context.networkManager });
+  subscribeToSignal(): Stream<SignalResponse> {
+    return subscribeToSignal({ networkManager: this.params.context.networkManager });
   }
 
   subscribeToSwarmInfo(): Stream<SubscribeToSwarmInfoResponse> {

package/src/packlets/devtools/feeds.ts

@@ -18,17 +18,17 @@ import { ComplexMap } from '@dxos/util';
 export const subscribeToFeeds = (
   { feedStore }: { feedStore: FeedStore<FeedMessage> },
   { feedKeys }: SubscribeToFeedsRequest
-) =>
-  new Stream<SubscribeToFeedsResponse>(({ next }) => {
+) => {
+  return new Stream<SubscribeToFeedsResponse>(({ next }) => {
     if (feedKeys?.length === 0) {
       return;
     }
 
-    const feedMap = new ComplexMap<PublicKey, FeedWrapper<FeedMessage>>(PublicKey.hash);
     const subscriptions = new EventSubscriptions();
+    const feedMap = new ComplexMap<PublicKey, FeedWrapper<FeedMessage>>(PublicKey.hash);
 
     const update = () => {
-      const feeds = feedStore.feeds;
+      const { feeds } = feedStore;
       feeds
         .filter((feed) => !feedKeys?.length || feedKeys.some((feedKey) => feedKey.equals(feed.key)))
         .forEach((feed) => {
@@ -38,6 +38,7 @@ export const subscribeToFeeds = (
             subscriptions.add(feed.off('close', update));
           }
         });
+
       next({
         feeds: Array.from(feedMap.values()).map((feed) => ({ feedKey: feed.key, length: feed.properties.length }))
       });
@@ -50,12 +51,13 @@ export const subscribeToFeeds = (
       subscriptions.clear();
     };
   });
+};
 
 export const subscribeToFeedBlocks = (
   { feedStore }: { feedStore: FeedStore<FeedMessage> },
   { feedKey, maxBlocks = 10 }: SubscribeToFeedBlocksRequest
-) =>
-  new Stream<SubscribeToFeedBlocksResponse>(({ next }) => {
+) => {
+  return new Stream<SubscribeToFeedBlocksResponse>(({ next }) => {
     if (!feedKey) {
       return;
     }
@@ -77,9 +79,11 @@ export const subscribeToFeedBlocks = (
             break;
           }
         }
+
         next({
           blocks: blocks.slice(-maxBlocks)
         });
+
         await iterator.close();
       };
 
@@ -96,3 +100,4 @@ export const subscribeToFeedBlocks = (
       clearTimeout(timeout);
     };
   });
+};

package/src/packlets/devtools/network.ts

@@ -3,15 +3,15 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf';
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
-import { CommandTrace } from '@dxos/messaging';
 import { NetworkManager } from '@dxos/network-manager';
 import {
   GetNetworkPeersRequest,
   GetNetworkPeersResponse,
   SubscribeToNetworkTopicsResponse,
   SubscribeToSignalStatusResponse,
-  SubscribeToSignalTraceResponse,
+  SignalResponse,
   SubscribeToSwarmInfoResponse
 } from '@dxos/protocols/proto/dxos/devtools/host';
 
@@ -30,14 +30,25 @@ export const subscribeToNetworkStatus = ({ networkManager }: { networkManager: N
     update();
   });
 
-export const subscribeToSignalTrace = ({ networkManager }: { networkManager: NetworkManager }) =>
-  new Stream<SubscribeToSignalTraceResponse>(({ next }) => {
-    next({ events: [] });
-    const trace: CommandTrace[] = [];
-    networkManager.signalManager.commandTrace.on((msg) => {
-      trace.push(msg);
-      next({ events: trace.map((msg) => JSON.stringify(msg)) });
+export const subscribeToSignal = ({ networkManager }: { networkManager: NetworkManager }) =>
+  new Stream<SignalResponse>(({ next }) => {
+    const ctx = new Context();
+    networkManager.signalManager.onMessage.on(ctx, (message) => {
+      next({
+        message: {
+          author: message.author.asUint8Array(),
+          recipient: message.recipient.asUint8Array(),
+          payload: message.payload
+        },
+        receivedAt: new Date()
+      });
     });
+    networkManager.signalManager.swarmEvent.on(ctx, (swarmEvent) => {
+      next({ swarmEvent: swarmEvent.swarmEvent, receivedAt: new Date() });
+    });
+    return () => {
+      return ctx.dispose();
+    };
   });
 
 export const subscribeToNetworkTopics = ({ networkManager }: { networkManager: NetworkManager }) =>

package/src/packlets/devtools/spaces.ts

@@ -3,14 +3,14 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf';
-import { Space } from '@dxos/echo-db';
+import { Space } from '@dxos/echo-pipeline';
 import { SubscribeToSpacesRequest, SubscribeToSpacesResponse } from '@dxos/protocols/proto/dxos/devtools/host';
 import { SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 
 import { ServiceContext } from '../services';
 
-export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: SubscribeToSpacesRequest) =>
-  new Stream<SubscribeToSpacesResponse>(({ next }) => {
+export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: SubscribeToSpacesRequest) => {
+  return new Stream<SubscribeToSpacesResponse>(({ next }) => {
     let unsubscribe: () => void;
 
     const update = async () => {
@@ -20,7 +20,7 @@ export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: S
       );
 
       next({
-        spaces: filteredSpaces.map((space) => {
+        spaces: filteredSpaces.map((space): SubscribeToSpacesResponse.SpaceInfo => {
           const spaceMetadata = context.metadataStore.spaces.find((spaceMetadata: SpaceMetadata) =>
             spaceMetadata.key.equals(space.key)
           );
@@ -28,10 +28,10 @@ export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: S
           return {
             key: space.key,
             isOpen: space.isOpen,
-            timeframe: spaceMetadata?.latestTimeframe,
+            timeframe: spaceMetadata?.dataTimeframe,
             genesisFeed: space.genesisFeedKey,
-            controlFeed: space.controlFeedKey,
-            dataFeed: space.dataFeedKey
+            controlFeed: space.controlFeedKey!, // TODO(dmaretskyi): Those keys may be missing.
+            dataFeed: space.dataFeedKey!
           };
         })
       });
@@ -50,3 +50,4 @@ export const subscribeToSpaces = (context: ServiceContext, { spaceKeys = [] }: S
       clearTimeout(timeout);
     };
   });
+};

package/src/packlets/identity/authenticator.test.ts

@@ -12,16 +12,16 @@ import { PublicKey } from '@dxos/keys';
 import { describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
-import { createHaloAuthProvider, HaloAuthVerifier } from './authenticator';
+import { createAuthProvider, TrustedKeySetAuthVerifier } from './authenticator';
 
 describe('identity/authenticator', () => {
   test('verifies credentials', async () => {
     const keyring = new Keyring();
     const deviceKey = await keyring.createKey();
     const signer = createCredentialSignerWithKey(keyring, deviceKey);
-    const authProvider = createHaloAuthProvider(signer);
-    const authVerifier = new HaloAuthVerifier({
-      trustedDevicesProvider: () => new ComplexSet(PublicKey.hash, [deviceKey]),
+    const authProvider = createAuthProvider(signer);
+    const authVerifier = new TrustedKeySetAuthVerifier({
+      trustedKeysProvider: () => new ComplexSet(PublicKey.hash, [deviceKey]),
       update: new Event(),
       authTimeout: 10
     });

package/src/packlets/identity/authenticator.ts

@@ -5,13 +5,13 @@
 import { Event, Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { verifyCredential, CredentialSigner } from '@dxos/credentials';
-import { AuthProvider, AuthVerifier } from '@dxos/echo-db';
+import { AuthProvider, AuthVerifier } from '@dxos/echo-pipeline';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
 import { ComplexSet } from '@dxos/util';
 
-export const createHaloAuthProvider =
+export const createAuthProvider =
   (signer: CredentialSigner): AuthProvider =>
   async (nonce) => {
     const credential = await signer.createCredential({
@@ -25,8 +25,9 @@ export const createHaloAuthProvider =
     return schema.getCodecForType('dxos.halo.credentials.Credential').encode(credential);
   };
 
-export type HaloAuthVerifierParams = {
-  trustedDevicesProvider: () => ComplexSet<PublicKey>;
+export type TrustedKeySetAuthVerifierParams = {
+  // TODO(dmaretskyi): Change to `isTrusted: (key) => bool`.
+  trustedKeysProvider: () => ComplexSet<PublicKey>;
   update: Event<void>;
   /**
    * Timeout to wait for the device key to be added to the trusted set.
@@ -35,26 +36,25 @@ export type HaloAuthVerifierParams = {
 };
 
 /**
- * Verifies credentials of another device of the same identity in the HALO space.
- * Will wait up to `authTimeout` for the device key to be added to the trusted set.
+ * Verifies credentials of another member in the space based on a set of trusted key.
+ * Will wait up to `authTimeout` for the key to be added to the trusted set.
  */
-export class HaloAuthVerifier {
+export class TrustedKeySetAuthVerifier {
   private _ctx = new Context();
 
-  constructor(private readonly _params: HaloAuthVerifierParams) {}
+  // prettier-ignore
+  constructor(
+    private readonly _params: TrustedKeySetAuthVerifierParams
+  ) {}
 
   async close() {
     await this._ctx.dispose();
   }
 
-  private _isTrustedDevice(deviceKey: PublicKey) {
-    const deviceSet = this._params.trustedDevicesProvider();
-    return deviceSet.has(deviceKey);
-  }
-
   get verifier(): AuthVerifier {
     return async (nonce, auth) => {
       const credential = schema.getCodecForType('dxos.halo.credentials.Credential').decode(auth);
+      log('authenticating...', { credential });
 
       const result = await verifyCredential(credential);
       if (result.kind === 'fail') {
@@ -67,7 +67,8 @@ export class HaloAuthVerifier {
         return false;
       }
 
-      if (this._isTrustedDevice(credential.issuer)) {
+      if (this._isTrustedKey(credential.issuer)) {
+        log('key is not currently in trusted set, waiting...', { key: credential.issuer });
         return true;
       }
 
@@ -75,14 +76,18 @@ export class HaloAuthVerifier {
       this._ctx.onDispose(() => {
         trigger.wake(false);
       });
+
       const clear = this._params.update.on(this._ctx, () => {
-        if (this._isTrustedDevice(credential.issuer)) {
+        if (this._isTrustedKey(credential.issuer)) {
+          log('auth success', { key: credential.issuer });
           trigger.wake(true);
+        } else {
+          log('key is not currently in trusted set, waiting...', { key: credential.issuer });
         }
       });
+
       try {
-        await trigger.wait({ timeout: this._params.authTimeout });
-        return true;
+        return await trigger.wait({ timeout: this._params.authTimeout });
       } catch {
         return false;
       } finally {
@@ -90,4 +95,9 @@ export class HaloAuthVerifier {
       }
     };
   }
+
+  private _isTrustedKey(deviceKey: PublicKey) {
+    const deviceSet = this._params.trustedKeysProvider();
+    return deviceSet.has(deviceKey);
+  }
 }

package/src/packlets/identity/identity-manager.test.ts

@@ -4,7 +4,7 @@
 
 import { expect } from 'chai';
 
-import { valueEncoding, MetadataStore, SpaceManager, AuthStatus } from '@dxos/echo-db';
+import { valueEncoding, MetadataStore, SpaceManager, AuthStatus } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
@@ -46,11 +46,12 @@ describe('identity/identity-manager', () => {
       feedStore,
       networkManager
     });
-    const identityManager = new IdentityManager(metadataStore, keyring, spaceManager);
+    const identityManager = new IdentityManager(metadataStore, keyring, feedStore, spaceManager);
 
     return {
       identityManager,
-      feedStore
+      feedStore,
+      keyring
     };
   };
 
@@ -90,23 +91,31 @@ describe('identity/identity-manager', () => {
 
     const peer2 = await setupPeer({ signalContext });
 
+    const deviceKey = await peer2.keyring.createKey();
+    const controlFeedKey = await peer2.keyring.createKey();
+    const dataFeedKey = await peer2.keyring.createKey();
+
+    await identity1.controlPipeline.writer.write({
+      credential: {
+        credential: await identity1.getIdentityCredentialSigner().createCredential({
+          subject: deviceKey,
+          assertion: {
+            '@type': 'dxos.halo.credentials.AuthorizedDevice',
+            identityKey: identity1.identityKey,
+            deviceKey
+          }
+        })
+      }
+    });
+
     // Identity2 is not yet ready at this point. Peer1 needs to admit peer2 device key and feed keys.
     const identity2 = await peer2.identityManager.acceptIdentity({
       identityKey: identity1.identityKey,
+      deviceKey,
       haloSpaceKey: identity1.haloSpaceKey,
-      haloGenesisFeedKey: identity1.haloGenesisFeedKey
-    });
-
-    await identity1.controlPipeline.writer.write({
-      '@type': 'dxos.echo.feed.CredentialsMessage',
-      credential: await identity1.getIdentityCredentialSigner().createCredential({
-        subject: identity2.deviceKey,
-        assertion: {
-          '@type': 'dxos.halo.credentials.AuthorizedDevice',
-          identityKey: identity2.identityKey,
-          deviceKey: identity2.deviceKey
-        }
-      })
+      haloGenesisFeedKey: identity1.haloGenesisFeedKey,
+      controlFeedKey,
+      dataFeedKey
     });
 
     // TODO(dmaretskyi): We'd also need to admit device2's feeds otherwise messages from them won't be processed by the pipeline.

package/src/packlets/identity/identity-manager.ts

@@ -6,15 +6,17 @@ import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
 import { createCredentialSignerWithKey, CredentialGenerator } from '@dxos/credentials';
-import { MetadataStore, SpaceManager, SwarmIdentity } from '@dxos/echo-db';
+import { MetadataStore, SpaceManager, SwarmIdentity } from '@dxos/echo-pipeline';
+import { FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
+import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed, IdentityRecord, SpaceRecord } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { deferFunction } from '@dxos/util';
 
 import { Identity } from '../identity';
-import { createHaloAuthProvider } from './authenticator';
+import { createAuthProvider } from './authenticator';
 
 interface ConstructSpaceParams {
   spaceRecord: SpaceRecord;
@@ -24,8 +26,11 @@ interface ConstructSpaceParams {
 
 export type JoinIdentityParams = {
   identityKey: PublicKey;
+  deviceKey: PublicKey;
   haloSpaceKey: PublicKey;
   haloGenesisFeedKey: PublicKey;
+  controlFeedKey: PublicKey;
+  dataFeedKey: PublicKey;
 };
 
 export type CreateIdentityOptions = {
@@ -43,6 +48,7 @@ export class IdentityManager {
   constructor(
     private readonly _metadataStore: MetadataStore,
     private readonly _keyring: Keyring,
+    private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _spaceManager: SpaceManager
   ) {}
 
@@ -113,8 +119,7 @@ export class IdentityManager {
 
       for (const credential of credentials) {
         await identity.controlPipeline.writer.write({
-          '@type': 'dxos.echo.feed.CredentialsMessage',
-          credential
+          credential: { credential }
         });
       }
     }
@@ -141,12 +146,12 @@ export class IdentityManager {
 
     const identityRecord: IdentityRecord = {
       identityKey: params.identityKey,
-      deviceKey: await this._keyring.createKey(),
+      deviceKey: params.deviceKey,
       haloSpace: {
         spaceKey: params.haloSpaceKey,
         genesisFeedKey: params.haloGenesisFeedKey,
-        writeControlFeedKey: await this._keyring.createKey(),
-        writeDataFeedKey: await this._keyring.createKey()
+        writeControlFeedKey: params.controlFeedKey,
+        writeDataFeedKey: params.dataFeedKey
       }
     };
     const identity = await this._constructIdentity(identityRecord);
@@ -154,7 +159,9 @@ export class IdentityManager {
     await identity.open();
     this._identity = identity;
     await this._metadataStore.setIdentityRecord(identityRecord);
+    await this._identity.ready();
     this.stateUpdate.emit();
+    log('accepted identity', { identityKey: identity.identityKey, deviceKey: identity.deviceKey });
     return identity;
   }
 
@@ -162,17 +169,24 @@ export class IdentityManager {
     assert(!this._identity);
     log('constructing identity', { identityRecord });
 
+    // Must be created before the space so the feeds are writable.
+    const controlFeed = await this._feedStore.openFeed(identityRecord.haloSpace.writeControlFeedKey, {
+      writable: true
+    });
+    const dataFeed = await this._feedStore.openFeed(identityRecord.haloSpace.writeDataFeedKey, { writable: true });
+
     const space = await this._constructSpace({
       spaceRecord: identityRecord.haloSpace,
       swarmIdentity: {
         peerKey: identityRecord.deviceKey,
-        credentialProvider: createHaloAuthProvider(
-          createCredentialSignerWithKey(this._keyring, identityRecord.deviceKey)
-        ),
+        credentialProvider: createAuthProvider(createCredentialSignerWithKey(this._keyring, identityRecord.deviceKey)),
         credentialAuthenticator: deferFunction(() => identity.authVerifier.verifier)
       },
       identityKey: identityRecord.identityKey
     });
+    space.setControlFeed(controlFeed);
+    space.setDataFeed(dataFeed);
+
     const identity: Identity = new Identity({
       space,
       signer: this._keyring,
@@ -188,9 +202,7 @@ export class IdentityManager {
     return this._spaceManager.constructSpace({
       metadata: {
         key: spaceRecord.spaceKey,
-        genesisFeedKey: spaceRecord.genesisFeedKey,
-        controlFeedKey: spaceRecord.writeControlFeedKey,
-        dataFeedKey: spaceRecord.writeDataFeedKey
+        genesisFeedKey: spaceRecord.genesisFeedKey
       },
       swarmIdentity,
       onNetworkConnection: () => {}