@dxos/echo-pipeline 0.5.8-main.f69e6e4 → 0.5.8

package/src/automerge/automerge-repo.test.ts

@@ -3,40 +3,16 @@
 //
 
 import { expect } from 'chai';
-import waitForExpect from 'wait-for-expect';
 
-import { asyncTimeout, sleep } from '@dxos/async';
 import { type Heads, change, clone, equals, from, getBackend, getHeads } from '@dxos/automerge/automerge';
-import { type Message, Repo, type PeerId, type DocumentId, type HandleState } from '@dxos/automerge/automerge-repo';
+import { Repo } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
-import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
-import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { describe, openAndClose, test } from '@dxos/test';
 
-import { EchoNetworkAdapter } from './echo-network-adapter';
 import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
-import { MeshEchoReplicator } from './mesh-echo-replicator';
-import { TestAdapter } from '../testing';
 
 describe('AutomergeRepo', () => {
-  test('change events', () => {
-    const repo = new Repo({ network: [] });
-    const handle = repo.create<{ field?: string }>();
-
-    let valueDuringChange: string | undefined;
-
-    handle.addListener('change', (doc) => {
-      valueDuringChange = handle.docSync().field;
-    });
-
-    handle.change((doc: any) => {
-      doc.field = 'value';
-    });
-
-    expect(valueDuringChange).to.eq('value');
-  });
-
   test('flush', async () => {
     const level = createTestLevel();
     const storage = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
@@ -91,428 +67,4 @@ describe('AutomergeRepo', () => {
     expect(equals(a, b)).to.be.false;
     expect(equals(a, c)).to.be.true;
   });
-
-  describe('network', () => {
-    test('basic networking', async () => {
-      const hostAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => clientAdapter.receive(message),
-      });
-      const clientAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => hostAdapter.receive(message),
-      });
-
-      const host = new Repo({
-        network: [hostAdapter],
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-      });
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
-
-      const handle = host.create();
-      const text = 'Hello world';
-      handle.change((doc: any) => {
-        doc.text = text;
-      });
-
-      const docOnClient = client.find(handle.url);
-      expect((await asyncTimeout(docOnClient.doc(), 1000)).text).to.equal(text);
-    });
-
-    test('share policy gets enabled afterwards', async () => {
-      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
-      let sharePolicy = false;
-
-      const host = new Repo({
-        network: [hostAdapter],
-        peerId: 'host' as PeerId,
-        sharePolicy: async () => sharePolicy,
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-        peerId: 'client' as PeerId,
-        sharePolicy: async () => sharePolicy,
-      });
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
-
-      const handle = host.create();
-      const text = 'Hello world';
-      handle.change((doc: any) => {
-        doc.text = text;
-      });
-
-      {
-        const docOnClient = client.find(handle.url);
-        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
-      }
-
-      sharePolicy = true;
-
-      {
-        const docOnClient = client.find(handle.url);
-        // TODO(mykola): We expect the document to be available here, but it's not.
-        await asyncTimeout(docOnClient.whenReady(['unavailable']), 1000);
-      }
-    });
-
-    test('two documents and share policy switching', async () => {
-      const [hostAdapter, clientAdapter] = TestAdapter.createPair();
-      const allowedDocs: DocumentId[] = [];
-
-      const host: Repo = new Repo({
-        network: [hostAdapter],
-        peerId: 'host' as PeerId,
-        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!host.handles[docId] : false),
-      });
-
-      const client: Repo = new Repo({
-        network: [clientAdapter],
-        peerId: 'client' as PeerId,
-        sharePolicy: async (_, docId) => (docId ? allowedDocs.includes(docId) && !!client.handles[docId] : false),
-      });
-
-      const firstHandle = host.create();
-      firstHandle.change((doc: any) => (doc.text = 'Hello world'));
-      await host.find(firstHandle.url).whenReady();
-      allowedDocs.push(firstHandle.documentId);
-
-      {
-        // Initiate connection.
-        hostAdapter.ready();
-        clientAdapter.ready();
-        await hostAdapter.onConnect.wait();
-        await clientAdapter.onConnect.wait();
-        hostAdapter.peerCandidate(clientAdapter.peerId!);
-        clientAdapter.peerCandidate(hostAdapter.peerId!);
-      }
-
-      {
-        const firstDocOnClient = client.find(firstHandle.url);
-        await asyncTimeout(firstDocOnClient.whenReady(), 1000);
-        expect(firstDocOnClient.docSync().text).to.equal('Hello world');
-      }
-
-      const secondHandle = host.create();
-      secondHandle.change((doc: any) => (doc.text = 'Hello world'));
-      await host.find(secondHandle.url).whenReady();
-      allowedDocs.push(secondHandle.documentId);
-
-      {
-        const secondDocOnClient = client.find(secondHandle.url);
-        await asyncTimeout(secondDocOnClient.whenReady(), 1000);
-        expect(secondDocOnClient.docSync().text).to.equal('Hello world');
-      }
-    });
-
-    test('recovering from a lost connection', async () => {
-      let connectionState: 'on' | 'off' = 'on';
-
-      const hostAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => clientAdapter.receive(message)),
-      });
-      const clientAdapter: TestAdapter = new TestAdapter({
-        send: (message: Message) => connectionState === 'on' && sleep(10).then(() => hostAdapter.receive(message)),
-      });
-
-      const host = new Repo({
-        network: [hostAdapter],
-      });
-      const client = new Repo({
-        network: [clientAdapter],
-      });
-
-      // Establish connection.
-      hostAdapter.ready();
-      clientAdapter.ready();
-      await hostAdapter.onConnect.wait();
-      await clientAdapter.onConnect.wait();
-      hostAdapter.peerCandidate(clientAdapter.peerId!);
-      clientAdapter.peerCandidate(hostAdapter.peerId!);
-
-      const handle = host.create();
-      const docOnClient = client.find(handle.url);
-      {
-        const sanityText = 'Hello world';
-        handle.change((doc: any) => {
-          doc.sanityText = sanityText;
-        });
-
-        expect((await asyncTimeout(docOnClient.doc(), 1000)).sanityText).to.equal(sanityText);
-      }
-
-      // Disrupt connection.
-      const offlineText = 'This has been written while the connection was off';
-      {
-        connectionState = 'off';
-
-        handle.change((doc: any) => {
-          doc.offlineText = offlineText;
-        });
-
-        await sleep(100);
-        expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).to.be.undefined;
-      }
-
-      // Re-establish connection.
-      const onlineText = 'This has been written after the connection was re-established';
-      {
-        connectionState = 'on';
-        hostAdapter.peerDisconnected(clientAdapter.peerId!);
-        clientAdapter.peerDisconnected(hostAdapter.peerId!);
-        hostAdapter.peerCandidate(clientAdapter.peerId!);
-        clientAdapter.peerCandidate(hostAdapter.peerId!);
-
-        handle.change((doc: any) => {
-          doc.onlineText = onlineText;
-        });
-        await sleep(100);
-        expect((await asyncTimeout(docOnClient.doc(), 1000)).onlineText).to.equal(onlineText);
-        expect((await asyncTimeout(docOnClient.doc(), 1000)).offlineText).to.equal(offlineText);
-      }
-    });
-
-    test('integration test with teleport', async () => {
-      const [spaceKey] = PublicKey.randomSequence();
-
-      const createAutomergeRepo = async () => {
-        const meshAdapter = new MeshEchoReplicator();
-        const echoAdapter = new EchoNetworkAdapter({
-          getContainingSpaceForDocument: async () => spaceKey,
-        });
-        const repo = new Repo({
-          network: [echoAdapter],
-        });
-        await echoAdapter.open();
-        await echoAdapter.whenConnected();
-        await echoAdapter.addReplicator(meshAdapter);
-        return { repo, meshAdapter };
-      };
-      const peer1 = await createAutomergeRepo();
-      const peer2 = await createAutomergeRepo();
-
-      const handle = peer1.repo.create();
-
-      const teleportBuilder = new TeleportBuilder();
-      afterTest(() => teleportBuilder.destroy());
-
-      const [teleportPeer1, teleportPeer2] = teleportBuilder.createPeers({ factory: () => new TeleportPeer() });
-      {
-        // Initiate connection.
-        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
-        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
-        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
-
-        // Test connection.
-        const text = 'Hello world';
-        handle.change((doc: any) => {
-          doc.text = text;
-        });
-        await waitForExpect(async () => {
-          const docOnPeer2 = peer2.repo.find(handle.url);
-          const doc = await asyncTimeout(docOnPeer2.doc(), 1000);
-          expect(doc.text).to.eq(text);
-        }, 1000);
-      }
-
-      const offlineText = 'This has been written while the connection was off';
-      {
-        // Disconnect peers.
-        await teleportBuilder.disconnect(teleportPeer1, teleportPeer2);
-
-        // Make offline changes.
-        const offlineText = 'This has been written while the connection was off';
-        handle.change((doc: any) => {
-          doc.offlineText = offlineText;
-        });
-        const docOnPeer2 = peer2.repo.find(handle.url);
-        await sleep(100);
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.be.undefined;
-      }
-
-      {
-        const docOnPeer2 = peer2.repo.find(handle.url);
-        const receivedUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
-
-        // Reconnect peers.
-        const [connection1, connection2] = await teleportBuilder.connect(teleportPeer1, teleportPeer2);
-        connection1.teleport.addExtension('automerge', peer1.meshAdapter.createExtension());
-        connection2.teleport.addExtension('automerge', peer2.meshAdapter.createExtension());
-
-        // Wait for offline changes to be synced.
-        await receivedUpdate;
-        await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).offlineText).to.eq(offlineText);
-
-        // Test connection.
-        const onlineText = 'This has been written after the connection was re-established';
-        const receivedOnlineUpdate = new Promise((resolve, reject) => docOnPeer2.once('heads-changed', resolve));
-        handle.change((doc: any) => {
-          doc.onlineText = onlineText;
-        });
-        await receivedOnlineUpdate;
-        await docOnPeer2.whenReady();
-        expect((await asyncTimeout(docOnPeer2.doc(), 1000)).onlineText).to.eq(onlineText);
-      }
-    });
-
-    test('replication though a 4 peer chain', async () => {
-      const pairAB = TestAdapter.createPair();
-      const pairBC = TestAdapter.createPair();
-      const pairCD = TestAdapter.createPair();
-
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [pairAB[0]],
-        sharePolicy: async () => true,
-      });
-      const _repoB = new Repo({
-        peerId: 'B' as any,
-        network: [pairAB[1], pairBC[0]],
-        sharePolicy: async () => true,
-      });
-      const _repoC = new Repo({
-        peerId: 'C' as any,
-        network: [pairBC[1], pairCD[0]],
-        sharePolicy: async () => true,
-      });
-      const repoD = new Repo({
-        peerId: 'D' as any,
-        network: [pairCD[1]],
-        sharePolicy: async () => true,
-      });
-
-      for (const pair of [pairAB, pairBC, pairCD]) {
-        pair[0].ready();
-        pair[1].ready();
-        await pair[0].onConnect.wait();
-        await pair[1].onConnect.wait();
-        pair[0].peerCandidate(pair[1].peerId!);
-        pair[1].peerCandidate(pair[0].peerId!);
-      }
-
-      const docA = repoA.create();
-      // NOTE: Doesn't work if the doc is empty.
-      docA.change((doc: any) => {
-        doc.text = 'Hello world';
-      });
-
-      // If we wait here for replication to finish naturally, the test will pass.
-
-      const docD = repoD.find(docA.url);
-
-      await docD.whenReady();
-    });
-
-    test('replication though a 3 peer chain', async () => {
-      const pairAB = TestAdapter.createPair();
-      const pairBC = TestAdapter.createPair();
-
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [pairAB[0]],
-        sharePolicy: async () => true,
-      });
-      const repoB = new Repo({
-        peerId: 'B' as any,
-        network: [pairAB[1], pairBC[0]],
-        sharePolicy: async () => true,
-      });
-      const repoC = new Repo({
-        peerId: 'C' as any,
-        network: [pairBC[1]],
-        sharePolicy: async () => true,
-      });
-
-      for (const pair of [pairAB, pairBC]) {
-        pair[0].ready();
-        pair[1].ready();
-        await pair[0].onConnect.wait();
-        await pair[1].onConnect.wait();
-        pair[0].peerCandidate(pair[1].peerId!);
-        pair[1].peerCandidate(pair[0].peerId!);
-      }
-
-      const docA = repoA.create();
-      // NOTE: Doesn't work if the doc is empty.
-      docA.change((doc: any) => {
-        doc.text = 'Hello world';
-      });
-
-      const _docB = repoB.find(docA.url);
-      const docC = repoC.find(docA.url);
-
-      await docC.whenReady();
-    });
-
-    test('replicate document after request', async () => {
-      const [adapter1, adapter2] = TestAdapter.createPair();
-      const repoA = new Repo({
-        peerId: 'A' as any,
-        network: [adapter1],
-        sharePolicy: async () => true,
-      });
-      const repoB = new Repo({
-        peerId: 'B' as any,
-        network: [adapter2],
-        sharePolicy: async () => true,
-      });
-
-      const unavailable: HandleState = 'unavailable';
-
-      {
-        // Connect repos.
-        adapter1.ready();
-        adapter2.ready();
-        await adapter1.onConnect.wait();
-        await adapter2.onConnect.wait();
-      }
-
-      const docA = repoA.create();
-      // NOTE: Doesn't work if the doc is empty.
-      docA.change((doc: any) => {
-        doc.text = 'Hello world';
-      });
-
-      const docB = repoB.find(docA.url);
-      {
-        // Request document from repoB.
-        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
-      }
-
-      {
-        // Failing to find a document.
-        // await (docB.whenReady([unavailable]), 1_000);
-      }
-
-      {
-        adapter1.peerCandidate(adapter2.peerId!);
-        await sleep(100);
-        adapter2.peerCandidate(adapter1.peerId!);
-      }
-
-      {
-        await asyncTimeout(docB.whenReady([unavailable]), 1_000);
-      }
-
-      {
-        // Note: Retry hack.
-        adapter1.peerDisconnected(adapter2.peerId!);
-        adapter2.peerDisconnected(adapter1.peerId!);
-        adapter1.peerCandidate(adapter2.peerId!);
-        adapter2.peerCandidate(adapter1.peerId!);
-
-        await asyncTimeout(docB.whenReady(), 1_000);
-      }
-    });
-  });
 });

package/src/automerge/migrations.ts

@@ -12,7 +12,7 @@ import { AutomergeStorageAdapter } from './automerge-storage-adapter';
 import { encodingOptions } from './leveldb-storage-adapter';
 
 export const levelMigration = async ({ db, directory }: { db: SublevelDB; directory: Directory }) => {
-  // Note: Make auto-migration from previous storage to leveldb here.
+  // Note: Make automigration from previous storage to leveldb here.
   const isNewLevel = !(await db
     .iterator<StorageKey, Uint8Array>({
       ...encodingOptions,
@@ -32,7 +32,6 @@ export const levelMigration = async ({ db, directory }: { db: SublevelDB; direct
   if (chunks.length === 0) {
     return;
   }
-
   const batch = db.batch();
   log.info('found chunks on old storage adapter', { chunks: chunks.length });
   for (const { key, data } of await oldStorageAdapter.loadRange([])) {

package/src/automerge/storage-adapter.test.ts

@@ -5,24 +5,18 @@
 import { expect } from 'chai';
 
 import { type StorageAdapterInterface } from '@dxos/automerge/automerge-repo';
-import { randomBytes } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
 import { StorageType, createStorage } from '@dxos/random-access-storage';
-import { afterTest, describe, test } from '@dxos/test';
-import { arrayToBuffer, bufferToArray, type MaybePromise } from '@dxos/util';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { type MaybePromise } from '@dxos/util';
 
 import { AutomergeStorageAdapter } from './automerge-storage-adapter';
 import { LevelDBStorageAdapter } from './leveldb-storage-adapter';
 
 const runTests = (
   testNamespace: string,
-  /** Run per test. Expects automatic clean-up with `afterTest`. */
-  createAdapter: (root?: string) => MaybePromise<{
-    adapter: StorageAdapterInterface;
-    /** Would be called automatically with `afterTest`. Exposed for mid-test clean-up. */
-    close: () => MaybePromise<void>;
-  }>,
+  /** Run per test. Expects automatic clean-up with `afterTest`. */ createAdapter: () => MaybePromise<StorageAdapterInterface>,
 ) => {
   describe(testNamespace, () => {
     const chunks = [
@@ -33,14 +27,14 @@ const runTests = (
     ];
 
     test('should store and retrieve data', async () => {
-      const { adapter } = await createAdapter();
+      const adapter = await createAdapter();
 
       await adapter.save(chunks[0].key, chunks[0].data);
       expect(await adapter.load(chunks[0].key)).to.deep.equal(chunks[0].data);
     });
 
     test('loadRange return inputs with correct prefixes', async () => {
-      const { adapter } = await createAdapter();
+      const adapter = await createAdapter();
 
       for (const chunk of chunks) {
         await adapter.save(chunk.key, chunk.data);
@@ -52,7 +46,7 @@ const runTests = (
     });
 
     test('deletion works', async () => {
-      const { adapter } = await createAdapter();
+      const adapter = await createAdapter();
 
       for (const chunk of chunks) {
         await adapter.save(chunk.key, chunk.data);
@@ -70,87 +64,27 @@ const runTests = (
       expect(await adapter.load(['a', 'b', 'c', '2'])).to.deep.equal(chunks[1].data);
       expect(await adapter.load(['a', 'b', 'd', '3'])).to.be.undefined;
     });
-
-    test('loadRange', async () => {
-      const root = `/tmp/${randomBytes(16).toString('hex')}`;
-      {
-        const { adapter, close } = await createAdapter(root);
-        await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
-        await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
-        await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
-        await close();
-      }
-
-      {
-        const { adapter } = await createAdapter(root);
-        const range = await adapter.loadRange(['test']);
-        expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).to.deep.eq(['one', 'two']);
-        expect(range.map((chunk) => chunk.key)).to.deep.eq([
-          ['test', '1'],
-          ['test', '2'],
-        ]);
-      }
-    });
-
-    test('removeRange', async () => {
-      const root = `/tmp/${randomBytes(16).toString('hex')}`;
-      {
-        const { adapter, close } = await createAdapter(root);
-        await adapter.save(['test', '1'], bufferToArray(Buffer.from('one')));
-        await adapter.save(['test', '2'], bufferToArray(Buffer.from('two')));
-        await adapter.save(['bar', '1'], bufferToArray(Buffer.from('bar')));
-        await close();
-      }
-
-      {
-        const { adapter } = await createAdapter(root);
-        await adapter.removeRange(['test']);
-        const range = await adapter.loadRange(['test']);
-        expect(range.map((chunk) => arrayToBuffer(chunk.data!).toString())).to.deep.eq([]);
-        const range2 = await adapter.loadRange(['bar']);
-        expect(range2.map((chunk) => arrayToBuffer(chunk.data!).toString())).to.deep.eq(['bar']);
-        expect(range2.map((chunk) => chunk.key)).to.deep.eq([['bar', '1']]);
-      }
-    });
   });
 };
 
 /**
  * Run tests for AutomergeStorageAdapter.
  */
-runTests('AutomergeStorageAdapter', (root?: string) => {
-  const storage = createStorage({ type: root ? StorageType.NODE : StorageType.RAM, root });
+runTests('AutomergeStorageAdapter', () => {
+  const storage = createStorage({ type: StorageType.RAM });
+  afterTest(() => storage.close());
   const dir = storage.createDirectory('automerge');
   const adapter = new AutomergeStorageAdapter(dir);
-
-  const close = async () => {
-    await adapter.close();
-    await storage.close();
-  };
-  afterTest(close);
-
-  return {
-    adapter,
-    close,
-  };
+  afterTest(() => adapter.close());
+  return adapter;
 });
 
 /**
  * Run tests for LevelDBStorageAdapter.
  */
-runTests('LevelDBStorageAdapter', async (root?: string) => {
-  const level = createTestLevel(root);
-  await level.open();
+runTests('LevelDBStorageAdapter', async () => {
+  const level = createTestLevel();
   const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-  await adapter.open?.();
-
-  const close = async () => {
-    await adapter.close();
-    await level.close();
-  };
-  afterTest(close);
-  return {
-    adapter,
-    close,
-  };
+  await openAndClose(level, adapter as any);
+  return adapter;
 });

package/src/space/space-manager.ts

@@ -8,7 +8,7 @@ import { failUndefined } from '@dxos/debug';
 import { type FeedStore } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type SwarmNetworkManager } from '@dxos/network-manager';
+import { type NetworkManager } from '@dxos/network-manager';
 import { trace } from '@dxos/protocols';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
@@ -16,14 +16,14 @@ import { type Teleport } from '@dxos/teleport';
 import { type BlobStore } from '@dxos/teleport-extension-object-sync';
 import { ComplexMap } from '@dxos/util';
 
-import { Space, createIdFromSpaceKey } from './space';
+import { Space } from './space';
 import { SpaceProtocol, type SwarmIdentity } from './space-protocol';
 import { SnapshotManager, type SnapshotStore } from '../db-host';
 import { type MetadataStore } from '../metadata';
 
 export type SpaceManagerParams = {
   feedStore: FeedStore<FeedMessage>;
-  networkManager: SwarmNetworkManager;
+  networkManager: NetworkManager;
   metadataStore: MetadataStore;
 
   /**
@@ -54,7 +54,7 @@ export type ConstructSpaceParams = {
 export class SpaceManager {
   private readonly _spaces = new ComplexMap<PublicKey, Space>(PublicKey.hash);
   private readonly _feedStore: FeedStore<FeedMessage>;
-  private readonly _networkManager: SwarmNetworkManager;
+  private readonly _networkManager: NetworkManager;
   private readonly _metadataStore: MetadataStore;
   private readonly _snapshotStore: SnapshotStore;
   private readonly _blobStore: BlobStore;
@@ -98,7 +98,6 @@ export class SpaceManager {
     const genesisFeed = await this._feedStore.openFeed(metadata.genesisFeedKey ?? failUndefined());
 
     const spaceKey = metadata.key;
-    const spaceId = await createIdFromSpaceKey(spaceKey);
     const protocol = new SpaceProtocol({
       topic: spaceKey,
       swarmIdentity,
@@ -110,7 +109,6 @@ export class SpaceManager {
     const snapshotManager = new SnapshotManager(this._snapshotStore, this._blobStore, protocol.blobSync);
 
     const space = new Space({
-      id: spaceId,
       spaceKey,
       protocol,
       genesisFeed,