@dxos/client-services 0.6.13-main.548ca8d → 0.6.13-staging.1e988a3

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

@@ -7,7 +7,6 @@ import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createCredentialSignerWithKey, CredentialGenerator } from '@dxos/credentials';
 import { type MetadataStore, type SpaceManager, type SwarmIdentity } from '@dxos/echo-pipeline';
-import { type EdgeConnection } from '@dxos/edge-client';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -15,7 +14,6 @@ import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
 import { Device, DeviceKind } from '@dxos/protocols/proto/dxos/client/services';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type IdentityRecord, type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import {
@@ -65,20 +63,9 @@ export type CreateIdentityOptions = {
   deviceProfile?: DeviceProfileDocument;
 };
 
-export type IdentityManagerCallbacks = {
-  onIdentityConstruction?: (identity: Identity) => void;
-};
-
-export type IdentityManagerParams = {
-  metadataStore: MetadataStore;
-  keyring: Keyring;
-  feedStore: FeedStore<FeedMessage>;
-  spaceManager: SpaceManager;
-  edgeConnection?: EdgeConnection;
-  edgeFeatures?: Runtime.Client.EdgeFeatures;
+export type IdentityManagerRuntimeParams = {
   devicePresenceAnnounceInterval?: number;
   devicePresenceOfflineTimeout?: number;
-  callbacks?: IdentityManagerCallbacks;
 };
 
 // TODO(dmaretskyi): Rename: represents the peer's state machine.
@@ -86,29 +73,28 @@ export type IdentityManagerParams = {
 export class IdentityManager {
   readonly stateUpdate = new Event();
 
-  private readonly _metadataStore: MetadataStore;
-  private readonly _keyring: Keyring;
-  private readonly _feedStore: FeedStore<FeedMessage>;
-  private readonly _spaceManager: SpaceManager;
+  private _identity?: Identity;
   private readonly _devicePresenceAnnounceInterval: number;
   private readonly _devicePresenceOfflineTimeout: number;
-  private readonly _edgeConnection: EdgeConnection | undefined;
-  private readonly _edgeFeatures: Runtime.Client.EdgeFeatures | undefined;
-  private readonly _callbacks: IdentityManagerCallbacks | undefined;
-
-  private _identity?: Identity;
 
+  // TODO(burdon): IdentityManagerParams.
   // TODO(dmaretskyi): Perhaps this should take/generate the peerKey outside of an initialized identity.
-  constructor(params: IdentityManagerParams) {
-    this._metadataStore = params.metadataStore;
-    this._keyring = params.keyring;
-    this._feedStore = params.feedStore;
-    this._spaceManager = params.spaceManager;
-    this._edgeConnection = params.edgeConnection;
-    this._edgeFeatures = params.edgeFeatures;
-    this._devicePresenceAnnounceInterval = params.devicePresenceAnnounceInterval ?? DEVICE_PRESENCE_ANNOUNCE_INTERVAL;
-    this._devicePresenceOfflineTimeout = params.devicePresenceOfflineTimeout ?? DEVICE_PRESENCE_OFFLINE_TIMEOUT;
-    this._callbacks = params.callbacks;
+  constructor(
+    private readonly _metadataStore: MetadataStore,
+    private readonly _keyring: Keyring,
+    private readonly _feedStore: FeedStore<FeedMessage>,
+    private readonly _spaceManager: SpaceManager,
+    params?: IdentityManagerRuntimeParams,
+    private readonly _callbacks?: {
+      onIdentityConstruction?: (identity: Identity) => void;
+    },
+  ) {
+    const {
+      devicePresenceAnnounceInterval = DEVICE_PRESENCE_ANNOUNCE_INTERVAL,
+      devicePresenceOfflineTimeout = DEVICE_PRESENCE_OFFLINE_TIMEOUT,
+    } = params ?? {};
+    this._devicePresenceAnnounceInterval = devicePresenceAnnounceInterval;
+    this._devicePresenceOfflineTimeout = devicePresenceOfflineTimeout;
   }
 
   get identity() {
@@ -374,8 +360,6 @@ export class IdentityManager {
       signer: this._keyring,
       identityKey: identityRecord.identityKey,
       deviceKey: identityRecord.deviceKey,
-      edgeConnection: this._edgeConnection,
-      edgeFeatures: this._edgeFeatures,
     });
     log('done', { identityKey: identityRecord.identityKey });
     this._callbacks?.onIdentityConstruction?.(identity);

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

@@ -2,17 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type Identity, type IdentityService } from '@dxos/protocols/proto/dxos/client/services';
+import { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
 
 import { IdentityServiceImpl } from './identity-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
 
+chai.use(chaiAsPromised);
+
 describe('IdentityService', () => {
   let serviceContext: ServiceContext;
   let identityService: IdentityService;
@@ -45,7 +49,7 @@ describe('IdentityService', () => {
 
     test('fails to create identity if one already exists', async () => {
       await identityService.createIdentity({});
-      await expect(identityService.createIdentity({})).rejects.toThrowError('Identity already exists');
+      await expect(identityService.createIdentity({})).to.be.rejectedWith('Identity already exists');
     });
   });
 
@@ -68,7 +72,7 @@ describe('IdentityService', () => {
       query.subscribe(({ identity }) => {
         result.wake(identity);
       });
-      onTestFinished(() => query.close());
+      afterTest(() => query.close());
       expect(await result.wait()).to.be.undefined;
     });
 
@@ -78,7 +82,7 @@ describe('IdentityService', () => {
       query.subscribe(({ identity }) => {
         result.wake(identity);
       });
-      onTestFinished(() => query.close());
+      afterTest(() => query.close());
       expect(await result.wait()).to.be.undefined;
 
       result = new Trigger<Identity | undefined>();

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

@@ -2,9 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import expect from 'expect';
 
-import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, verifyCredential } from '@dxos/credentials';
 import {
@@ -16,9 +15,7 @@ import {
   SpaceProtocol,
   valueEncoding,
 } from '@dxos/echo-pipeline';
-import { type EdgeConnection, type MessageListener } from '@dxos/edge-client';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
-import { type FeedWrapper } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
@@ -27,6 +24,7 @@ import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
+import { afterTest, describe, test } from '@dxos/test';
 
 import { Identity } from './identity';
 
@@ -44,108 +42,16 @@ const createStores = () => {
 
 describe('identity/identity', () => {
   test('create', async () => {
-    const setup = await setupIdentity();
-
-    await writeGenesisCredential(setup);
-
-    // Wait for identity to be ready.
-    await setup.identity.ready();
-    const identitySigner = setup.identity.getIdentityCredentialSigner();
-    const credential = await identitySigner.createCredential({
-      subject: setup.identityKey,
-      assertion: {
-        '@type': 'dxos.halo.credentials.IdentityProfile',
-        profile: {
-          displayName: 'Alice',
-        },
-      },
-    });
-
-    expect(credential.issuer).toEqual(setup.identityKey);
-    expect(await verifyCredential(credential)).toEqual({ kind: 'pass' });
-  });
-
-  test('two devices', async () => {
-    const signalContext = new MemorySignalManagerContext();
-
-    const owner = await setupIdentity({ signalContext });
-    await writeGenesisCredential(owner);
-    await owner.identity.ready();
-
-    const secondDevice = (
-      await setupIdentity({
-        signalContext,
-        spaceKey: owner.spaceKey,
-        identityKey: owner.identityKey,
-        genesisFeedKey: owner.controlFeed.key,
-      })
-    ).identity;
-
-    //
-    // Second device admission
-    //
-    {
-      const signer = owner.identity.getIdentityCredentialSigner();
-      void owner.identity.controlPipeline.writer.write({
-        credential: {
-          credential: await signer.createCredential({
-            subject: secondDevice.deviceKey,
-            assertion: {
-              '@type': 'dxos.halo.credentials.AuthorizedDevice',
-              identityKey: owner.identityKey,
-              deviceKey: secondDevice.deviceKey,
-            },
-          }),
-        },
-      });
-
-      await secondDevice.ready();
-    }
-
-    expect(Array.from(owner.identity.authorizedDeviceKeys.keys())).toEqual([owner.deviceKey, secondDevice.deviceKey]);
-    expect(Array.from(secondDevice.authorizedDeviceKeys.keys())).toEqual([owner.deviceKey, secondDevice.deviceKey]);
-  });
-
-  test('edge feed replicator', async () => {
-    let replicationStarted = false;
-    const connectedEvent = new Event();
-    const setup = await setupIdentity({
-      edgeConnection: {
-        connected: connectedEvent,
-        open: async () => {},
-        close: async () => {},
-        addListener: (_: MessageListener): (() => void) => {
-          return () => {};
-        },
-        send: async (_) => {
-          replicationStarted = true;
-        },
-      } as EdgeConnection,
-    });
-
-    await writeGenesisCredential(setup);
-    connectedEvent.emit();
-
-    await expect.poll(() => replicationStarted).toBeTruthy();
-  });
-
-  const setupIdentity = async (args?: {
-    signalContext?: MemorySignalManagerContext;
-    spaceKey?: PublicKey;
-    identityKey?: PublicKey;
-    genesisFeedKey?: PublicKey;
-    edgeConnection?: EdgeConnection;
-  }): Promise<TestIdentitySetup> => {
     const { storage, metadataStore, blobStore } = createStores();
 
     const keyring = new Keyring();
+    const identityKey = await keyring.createKey();
     const deviceKey = await keyring.createKey();
-    const identityKey = args?.identityKey ?? (await keyring.createKey());
-    const spaceKey = args?.spaceKey ?? (await keyring.createKey());
+    const spaceKey = await keyring.createKey();
 
     const feedStore = new FeedStore<FeedMessage>({
       factory: new FeedFactory<FeedMessage>({
-        root: storage.createDirectory(),
+        root: storage.createDirectory('feeds'),
         signer: keyring,
         hypercore: {
           valueEncoding,
@@ -171,7 +77,7 @@ describe('identity/identity', () => {
       },
       blobStore,
       networkManager: new SwarmNetworkManager({
-        signalManager: new MemorySignalManager(args?.signalContext ?? new MemorySignalManagerContext()),
+        signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
         transportFactory: MemoryTransportFactory,
       }),
     });
@@ -181,7 +87,7 @@ describe('identity/identity', () => {
       id: await createIdFromSpaceKey(spaceKey),
       spaceKey,
       protocol,
-      genesisFeed: args?.genesisFeedKey ? await feedStore.openFeed(args.genesisFeedKey) : controlFeed,
+      genesisFeed: controlFeed,
       feedProvider: (feedKey) => feedStore.openFeed(feedKey),
       memberKey: identityKey,
       metadataStore,
@@ -197,37 +103,242 @@ describe('identity/identity', () => {
       identityKey,
       deviceKey,
       space,
-      edgeFeatures: args?.edgeConnection && { feedReplicator: true },
-      edgeConnection: args?.edgeConnection,
     });
 
     await identity.open(new Context());
-    onTestFinished(() => identity.close(new Context()));
-    return { identity, identityKey, keyring, deviceKey, controlFeed, spaceKey, dataFeed };
-  };
+    afterTest(() => identity.close(new Context()));
+
+    //
+    // Identity genesis
+    //
+    {
+      const generator = new CredentialGenerator(keyring, identityKey, deviceKey);
+      const credentials = [
+        ...(await generator.createSpaceGenesis(spaceKey, controlFeed.key)),
+        await generator.createDeviceAuthorization(deviceKey),
+        await generator.createFeedAdmission(spaceKey, dataFeed.key, AdmittedFeed.Designation.DATA),
+      ];
+
+      for (const credential of credentials) {
+        await identity.controlPipeline.writer.write({
+          credential: { credential },
+        });
+      }
+    }
+
+    // Wait for identity to be ready.
+    await identity.ready();
+    const identitySigner = identity.getIdentityCredentialSigner();
+    const credential = await identitySigner.createCredential({
+      subject: identityKey,
+      assertion: {
+        '@type': 'dxos.halo.credentials.IdentityProfile',
+        profile: {
+          displayName: 'Alice',
+        },
+      },
+    });
+
+    expect(credential.issuer).toEqual(identityKey);
+    expect(await verifyCredential(credential)).toEqual({ kind: 'pass' });
+  });
 
-  const writeGenesisCredential = async (setup: TestIdentitySetup) => {
-    const generator = new CredentialGenerator(setup.keyring, setup.identityKey, setup.deviceKey);
-    const credentials = [
-      ...(await generator.createSpaceGenesis(setup.spaceKey, setup.controlFeed.key)),
-      await generator.createDeviceAuthorization(setup.deviceKey),
-      await generator.createFeedAdmission(setup.spaceKey, setup.dataFeed.key, AdmittedFeed.Designation.DATA),
-    ];
-
-    for (const credential of credentials) {
-      await setup.identity.controlPipeline.writer.write({
-        credential: { credential },
+  test('two devices', async () => {
+    const signalContext = new MemorySignalManagerContext();
+
+    let spaceKey: PublicKey;
+    let identityKey: PublicKey;
+    let genesisFeedKey: PublicKey;
+    let identity1: Identity;
+    let identity2: Identity;
+
+    //
+    // First device
+    //
+    {
+      const { storage, metadataStore, blobStore } = createStores();
+
+      const keyring = new Keyring();
+      identityKey = await keyring.createKey();
+      const deviceKey = await keyring.createKey();
+      spaceKey = await keyring.createKey();
+
+      const feedStore = new FeedStore<FeedMessage>({
+        factory: new FeedFactory<FeedMessage>({
+          root: storage.createDirectory(),
+          signer: keyring,
+          hypercore: {
+            valueEncoding,
+          },
+        }),
+      });
+
+      const createFeed = async () => {
+        const feedKey = await keyring.createKey();
+        return feedStore.openFeed(feedKey, { writable: true });
+      };
+
+      const controlFeed = await createFeed();
+      genesisFeedKey = controlFeed.key;
+
+      const dataFeed = await createFeed();
+
+      const protocol = new SpaceProtocol({
+        topic: spaceKey,
+        swarmIdentity: {
+          peerKey: deviceKey,
+          identityKey,
+          credentialProvider: MOCK_AUTH_PROVIDER, // createHaloAuthProvider(createCredentialSignerWithKey(keyring, device_key)),
+          credentialAuthenticator: MOCK_AUTH_VERIFIER, // createHaloAuthVerifier(() => identity.authorizedDeviceKeys),
+        },
+        blobStore,
+        networkManager: new SwarmNetworkManager({
+          signalManager: new MemorySignalManager(signalContext),
+          transportFactory: MemoryTransportFactory,
+        }),
+      });
+
+      await metadataStore.setIdentityRecord({ haloSpace: { key: spaceKey }, identityKey, deviceKey });
+      const space = new Space({
+        id: await createIdFromSpaceKey(spaceKey),
+        spaceKey,
+        protocol,
+        genesisFeed: controlFeed,
+        feedProvider: (feedKey) => feedStore.openFeed(feedKey),
+        memberKey: identityKey,
+        metadataStore,
+        onDelegatedInvitationStatusChange: async () => {},
+        onMemberRolesChanged: async () => {},
       });
+      await space.setControlFeed(controlFeed);
+      await space.setDataFeed(dataFeed);
+
+      const identity = (identity1 = new Identity({
+        signer: keyring,
+        identityKey,
+        deviceKey,
+        space,
+      }));
+
+      await identity.open(new Context());
+      afterTest(() => identity.close(new Context()));
+
+      //
+      // Identity genesis
+      //
+      {
+        const generator = new CredentialGenerator(keyring, identityKey, deviceKey);
+        const credentials = [
+          ...(await generator.createSpaceGenesis(spaceKey, controlFeed.key)),
+          await generator.createDeviceAuthorization(deviceKey),
+          await generator.createFeedAdmission(spaceKey, dataFeed.key, AdmittedFeed.Designation.DATA),
+        ];
+
+        for (const credential of credentials) {
+          await identity.controlPipeline.writer.write({
+            credential: { credential },
+          });
+        }
+      }
+
+      // Wait for identity to be ready.
+      await identity.ready();
     }
-  };
-});
 
-type TestIdentitySetup = {
-  identity: Identity;
-  keyring: Keyring;
-  identityKey: PublicKey;
-  deviceKey: PublicKey;
-  spaceKey: PublicKey;
-  controlFeed: FeedWrapper<FeedMessage>;
-  dataFeed: FeedWrapper<FeedMessage>;
-};
+    //
+    // Second device
+    //
+    {
+      const { storage, metadataStore, blobStore } = createStores();
+
+      const keyring = new Keyring();
+      const deviceKey = await keyring.createKey();
+
+      const feedStore = new FeedStore<FeedMessage>({
+        factory: new FeedFactory<FeedMessage>({
+          root: storage.createDirectory(),
+          signer: keyring,
+          hypercore: {
+            valueEncoding,
+          },
+        }),
+      });
+
+      const createFeed = async () => {
+        const feedKey = await keyring.createKey();
+        return feedStore.openFeed(feedKey, { writable: true });
+      };
+
+      const controlFeed = await createFeed();
+      const dataFeed = await createFeed();
+
+      const protocol = new SpaceProtocol({
+        topic: spaceKey,
+        swarmIdentity: {
+          peerKey: deviceKey,
+          identityKey,
+          credentialProvider: MOCK_AUTH_PROVIDER, // createHaloAuthProvider(createCredentialSignerWithKey(keyring, device_key)),
+          credentialAuthenticator: MOCK_AUTH_VERIFIER, // createHaloAuthVerifier(() => identity.authorizedDeviceKeys),
+        },
+        blobStore,
+        networkManager: new SwarmNetworkManager({
+          signalManager: new MemorySignalManager(signalContext),
+          transportFactory: MemoryTransportFactory,
+        }),
+      });
+
+      await metadataStore.setIdentityRecord({
+        haloSpace: { key: spaceKey },
+        identityKey: identity1.identityKey,
+        deviceKey,
+      });
+      const space = new Space({
+        id: await createIdFromSpaceKey(spaceKey),
+        spaceKey,
+        protocol,
+        genesisFeed: await feedStore.openFeed(genesisFeedKey),
+        feedProvider: (feedKey) => feedStore.openFeed(feedKey),
+        memberKey: identityKey,
+        metadataStore,
+        onDelegatedInvitationStatusChange: async () => {},
+        onMemberRolesChanged: async () => {},
+      });
+      await space.setControlFeed(controlFeed);
+      await space.setDataFeed(dataFeed);
+
+      const identity = (identity2 = new Identity({
+        signer: keyring,
+        identityKey: identity1.identityKey,
+        deviceKey,
+        space,
+      }));
+
+      await identity.open(new Context());
+      afterTest(() => identity.close(new Context()));
+    }
+
+    //
+    // Second device admission
+    //
+    {
+      const signer = identity1.getIdentityCredentialSigner();
+      void identity1.controlPipeline.writer.write({
+        credential: {
+          credential: await signer.createCredential({
+            subject: identity2.deviceKey,
+            assertion: {
+              '@type': 'dxos.halo.credentials.AuthorizedDevice',
+              identityKey: identity1.identityKey,
+              deviceKey: identity2.deviceKey,
+            },
+          }),
+        },
+      });
+
+      await identity2.ready();
+    }
+
+    expect(Array.from(identity1.authorizedDeviceKeys.keys())).toEqual([identity1.deviceKey, identity2.deviceKey]);
+    expect(Array.from(identity2.authorizedDeviceKeys.keys())).toEqual([identity1.deviceKey, identity2.deviceKey]);
+  });
+});

package/src/packlets/identity/identity.ts

@@ -14,12 +14,10 @@ import {
 } from '@dxos/credentials';
 import { type Signer } from '@dxos/crypto';
 import { type Space } from '@dxos/echo-pipeline';
-import { type EdgeConnection } from '@dxos/edge-client';
-import { writeMessages, type FeedWrapper } from '@dxos/feed-store';
+import { writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import {
   AdmittedFeed,
@@ -34,7 +32,6 @@ import { type ComplexMap, ComplexSet } from '@dxos/util';
 
 import { TrustedKeySetAuthVerifier } from './authenticator';
 import { DefaultSpaceStateMachine } from './default-space-state-machine';
-import { EdgeFeedReplicator } from '../spaces';
 
 export type IdentityParams = {
   identityKey: PublicKey;
@@ -42,9 +39,6 @@ export type IdentityParams = {
   signer: Signer;
   space: Space;
   presence?: Presence;
-
-  edgeConnection?: EdgeConnection;
-  edgeFeatures?: Runtime.Client.EdgeFeatures;
 };
 
 /**
@@ -58,8 +52,6 @@ export class Identity {
   private readonly _deviceStateMachine: DeviceStateMachine;
   private readonly _profileStateMachine: ProfileStateMachine;
   private readonly _defaultSpaceStateMachine: DefaultSpaceStateMachine;
-  private readonly _edgeFeedReplicator?: EdgeFeedReplicator = undefined;
-
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   public readonly identityKey: PublicKey;
@@ -67,15 +59,15 @@ export class Identity {
 
   public readonly stateUpdate = new Event();
 
-  constructor(params: IdentityParams) {
-    this.space = params.space;
-    this._signer = params.signer;
-    this._presence = params.presence;
+  constructor({ space, signer, identityKey, deviceKey, presence }: IdentityParams) {
+    this.space = space;
+    this._signer = signer;
+    this._presence = presence;
 
-    this.identityKey = params.identityKey;
-    this.deviceKey = params.deviceKey;
+    this.identityKey = identityKey;
+    this.deviceKey = deviceKey;
 
-    log.trace('dxos.halo.device', { deviceKey: params.deviceKey });
+    log.trace('dxos.halo.device', { deviceKey });
 
     this._deviceStateMachine = new DeviceStateMachine({
       identityKey: this.identityKey,
@@ -96,10 +88,6 @@ export class Identity {
       update: this.stateUpdate,
       authTimeout: AUTH_TIMEOUT,
     });
-
-    if (params.edgeConnection && params.edgeFeatures?.feedReplicator) {
-      this._edgeFeedReplicator = new EdgeFeedReplicator({ messenger: params.edgeConnection, spaceId: this.space.id });
-    }
   }
 
   // TODO(burdon): Expose state object?
@@ -117,14 +105,7 @@ export class Identity {
     await this.space.spaceState.addCredentialProcessor(this._deviceStateMachine);
     await this.space.spaceState.addCredentialProcessor(this._profileStateMachine);
     await this.space.spaceState.addCredentialProcessor(this._defaultSpaceStateMachine);
-
-    if (this._edgeFeedReplicator) {
-      this.space.protocol.feedAdded.append(this._onFeedAdded);
-    }
-
     await this.space.open(ctx);
-
-    await this._edgeFeedReplicator?.open();
   }
 
   @trace.span()
@@ -134,13 +115,6 @@ export class Identity {
     await this.space.spaceState.removeCredentialProcessor(this._defaultSpaceStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._profileStateMachine);
     await this.space.spaceState.removeCredentialProcessor(this._deviceStateMachine);
-
-    if (this._edgeFeedReplicator) {
-      this.space.protocol.feedAdded.remove(this._onFeedAdded);
-    }
-
-    await this._edgeFeedReplicator?.close();
-
     await this.space.close();
   }
 
@@ -177,10 +151,6 @@ export class Identity {
     return this._presence;
   }
 
-  get signer() {
-    return this._signer;
-  }
-
   /**
    * Issues credentials as identity.
    * Requires identity to be ready.
@@ -253,8 +223,4 @@ export class Identity {
       ].map((credential): FeedMessage.Payload => ({ credential: { credential } })),
     );
   }
-
-  private _onFeedAdded = async (feed: FeedWrapper<any>) => {
-    await this._edgeFeedReplicator!.addFeed(feed);
-  };
 }