@dxos/echo-pipeline 0.5.6 → 0.5.7-main.1b479fd

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

@@ -3,16 +3,40 @@
 //
 
 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 { Repo } from '@dxos/automerge/automerge-repo';
+import { type Message, Repo, type PeerId, type DocumentId, type HandleState } from '@dxos/automerge/automerge-repo';
 import { randomBytes } from '@dxos/crypto';
+import { PublicKey } from '@dxos/keys';
 import { createTestLevel } from '@dxos/kv-store/testing';
-import { describe, openAndClose, test } from '@dxos/test';
+import { TestBuilder as TeleportBuilder, TestPeer as TeleportPeer } from '@dxos/teleport/testing';
+import { afterTest, 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') });
@@ -67,4 +91,428 @@ 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 automigration from previous storage to leveldb here.
+  // Note: Make auto-migration from previous storage to leveldb here.
   const isNewLevel = !(await db
     .iterator<StorageKey, Uint8Array>({
       ...encodingOptions,
@@ -32,6 +32,7 @@ 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,18 +5,24 @@
 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, openAndClose, test } from '@dxos/test';
-import { type MaybePromise } from '@dxos/util';
+import { afterTest, describe, test } from '@dxos/test';
+import { arrayToBuffer, bufferToArray, 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: () => MaybePromise<StorageAdapterInterface>,
+  /** 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>;
+  }>,
 ) => {
   describe(testNamespace, () => {
     const chunks = [
@@ -27,14 +33,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);
@@ -46,7 +52,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);
@@ -64,27 +70,87 @@ 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', () => {
-  const storage = createStorage({ type: StorageType.RAM });
-  afterTest(() => storage.close());
+runTests('AutomergeStorageAdapter', (root?: string) => {
+  const storage = createStorage({ type: root ? StorageType.NODE : StorageType.RAM, root });
   const dir = storage.createDirectory('automerge');
   const adapter = new AutomergeStorageAdapter(dir);
-  afterTest(() => adapter.close());
-  return adapter;
+
+  const close = async () => {
+    await adapter.close();
+    await storage.close();
+  };
+  afterTest(close);
+
+  return {
+    adapter,
+    close,
+  };
 });
 
 /**
  * Run tests for LevelDBStorageAdapter.
  */
-runTests('LevelDBStorageAdapter', async () => {
-  const level = createTestLevel();
+runTests('LevelDBStorageAdapter', async (root?: string) => {
+  const level = createTestLevel(root);
+  await level.open();
   const adapter = new LevelDBStorageAdapter({ db: level.sublevel('automerge') });
-  await openAndClose(level, adapter as any);
-  return adapter;
+  await adapter.open?.();
+
+  const close = async () => {
+    await adapter.close();
+    await level.close();
+  };
+  afterTest(close);
+  return {
+    adapter,
+    close,
+  };
 });

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 NetworkManager } from '@dxos/network-manager';
+import { type SwarmNetworkManager } 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 } from './space';
+import { Space, createIdFromSpaceKey } 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: NetworkManager;
+  networkManager: SwarmNetworkManager;
   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: NetworkManager;
+  private readonly _networkManager: SwarmNetworkManager;
   private readonly _metadataStore: MetadataStore;
   private readonly _snapshotStore: SnapshotStore;
   private readonly _blobStore: BlobStore;
@@ -98,6 +98,7 @@ 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,
@@ -109,6 +110,7 @@ export class SpaceManager {
     const snapshotManager = new SnapshotManager(this._snapshotStore, this._blobStore, protocol.blobSync);
 
     const space = new Space({
+      id: spaceId,
       spaceKey,
       protocol,
       genesisFeed,