@dxos/client-services 0.1.18 → 0.1.19

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

@@ -5,13 +5,14 @@
 import expect from 'expect';
 import assert from 'node:assert';
 
+import { Event } from '@dxos/async';
 import { createCredentialSignerWithKey } from '@dxos/credentials';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
-import { createHaloAuthProvider, createHaloAuthVerifier } from './authenticator';
+import { createHaloAuthProvider, HaloAuthVerifier } from './authenticator';
 
 describe('identity/authenticator', () => {
   test('verifies credentials', async () => {
@@ -19,11 +20,15 @@ describe('identity/authenticator', () => {
     const deviceKey = await keyring.createKey();
     const signer = createCredentialSignerWithKey(keyring, deviceKey);
     const authProvider = createHaloAuthProvider(signer);
-    const authVerifier = createHaloAuthVerifier(() => new ComplexSet(PublicKey.hash, [deviceKey]));
+    const authVerifier = new HaloAuthVerifier({
+      trustedDevicesProvider: () => new ComplexSet(PublicKey.hash, [deviceKey]),
+      update: new Event(),
+      authTimeout: 10
+    });
 
     const nonce = new Uint8Array([2, 1, 3, 7]);
     const credential = await authProvider(nonce);
     assert(credential);
-    expect(await authVerifier(nonce, credential)).toBeTruthy();
+    expect(await authVerifier.verifier(nonce, credential)).toBeTruthy();
   }).onlyEnvironments('nodejs');
 });

package/src/packlets/identity/authenticator.ts

@@ -2,6 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
+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 { PublicKey } from '@dxos/keys';
@@ -23,27 +25,69 @@ export const createHaloAuthProvider =
     return schema.getCodecForType('dxos.halo.credentials.Credential').encode(credential);
   };
 
-export const createHaloAuthVerifier =
-  (getDeviceSet: () => ComplexSet<PublicKey>): AuthVerifier =>
-  async (nonce, auth) => {
-    const credential = schema.getCodecForType('dxos.halo.credentials.Credential').decode(auth);
-    const deviceSet = getDeviceSet();
-
-    const result = await verifyCredential(credential);
-    if (result.kind === 'fail') {
-      log('Invalid credential', { result });
-      return false;
-    }
-
-    if (!credential.proof.nonce || !Buffer.from(nonce).equals(credential.proof.nonce)) {
-      log('Invalid nonce', { nonce, credential });
-      return false;
-    }
-
-    if (!deviceSet.has(credential.issuer)) {
-      log('Device not in allowed set');
-      return false;
-    }
-
-    return true;
-  };
+export type HaloAuthVerifierParams = {
+  trustedDevicesProvider: () => ComplexSet<PublicKey>;
+  update: Event<void>;
+  /**
+   * Timeout to wait for the device key to be added to the trusted set.
+   */
+  authTimeout: number;
+};
+
+/**
+ * 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.
+ */
+export class HaloAuthVerifier {
+  private _ctx = new Context();
+
+  constructor(private readonly _params: HaloAuthVerifierParams) {}
+
+  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);
+
+      const result = await verifyCredential(credential);
+      if (result.kind === 'fail') {
+        log('Invalid credential', { result });
+        return false;
+      }
+
+      if (!credential.proof.nonce || !Buffer.from(nonce).equals(credential.proof.nonce)) {
+        log('Invalid nonce', { nonce, credential });
+        return false;
+      }
+
+      if (this._isTrustedDevice(credential.issuer)) {
+        return true;
+      }
+
+      const trigger = new Trigger<boolean>();
+      this._ctx.onDispose(() => {
+        trigger.wake(false);
+      });
+      const clear = this._params.update.on(this._ctx, () => {
+        if (this._isTrustedDevice(credential.issuer)) {
+          trigger.wake(true);
+        }
+      });
+      try {
+        await trigger.wait({ timeout: this._params.authTimeout });
+        return true;
+      } catch {
+        return false;
+      } finally {
+        clear();
+      }
+    };
+  }
+}

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

@@ -4,7 +4,7 @@
 
 import { expect } from 'chai';
 
-import { valueEncoding, MetadataStore } from '@dxos/echo-db';
+import { valueEncoding, MetadataStore, SpaceManager, AuthStatus } from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
@@ -13,7 +13,6 @@ import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { createStorage, Storage, StorageType } from '@dxos/random-access-storage';
 import { describe, test, afterTest } from '@dxos/test';
 
-import { createDefaultModelFactory } from '../services';
 import { IdentityManager } from './identity-manager';
 
 describe('identity/identity-manager', () => {
@@ -43,14 +42,11 @@ describe('identity/identity-manager', () => {
       signalManager: new MemorySignalManager(signalContext),
       transportFactory: MemoryTransportFactory
     });
-
-    const identityManager = new IdentityManager(
-      metadataStore,
+    const spaceManager = new SpaceManager({
       feedStore,
-      keyring,
-      networkManager,
-      createDefaultModelFactory()
-    );
+      networkManager
+    });
+    const identityManager = new IdentityManager(metadataStore, keyring, spaceManager);
 
     return {
       identityManager,
@@ -116,5 +112,11 @@ describe('identity/identity-manager', () => {
     // TODO(dmaretskyi): We'd also need to admit device2's feeds otherwise messages from them won't be processed by the pipeline.
     // This would mean that peer2 has replicated it's device credential chain from peer1 and is ready to issue credentials.
     await identity2.ready();
+
+    // Connection is authenticated.
+    expect(identity1.space.protocol.sessions.get(identity2.deviceKey)).to.exist;
+    expect(identity1.space.protocol.sessions.get(identity2.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
+    expect(identity2.space.protocol.sessions.get(identity1.deviceKey)).to.exist;
+    expect(identity2.space.protocol.sessions.get(identity1.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
   });
 });

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

@@ -5,30 +5,22 @@
 import assert from 'node:assert';
 
 import { Event } from '@dxos/async';
-import { CredentialGenerator } from '@dxos/credentials';
-import {
-  MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER,
-  MetadataStore,
-  Space,
-  SwarmIdentity,
-  Database,
-  SpaceProtocol
-} from '@dxos/echo-db';
-import { FeedStore } from '@dxos/feed-store';
+import { createCredentialSignerWithKey, CredentialGenerator } from '@dxos/credentials';
+import { MetadataStore, NoopDataPipelineController, SpaceManager, SwarmIdentity } from '@dxos/echo-db';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { ModelFactory } from '@dxos/model-factory';
-import { NetworkManager } from '@dxos/network-manager';
-import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed, IdentityRecord, SpaceRecord } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { Presence } from '@dxos/teleport-extension-presence';
+import { deferFunction } from '@dxos/util';
 
 import { Identity } from '../identity';
+import { createHaloAuthProvider } from './authenticator';
 
 interface ConstructSpaceParams {
   spaceRecord: SpaceRecord;
   swarmIdentity: SwarmIdentity;
+  identityKey: PublicKey;
 }
 
 export type JoinIdentityParams = {
@@ -51,10 +43,8 @@ export class IdentityManager {
   // TODO(dmaretskyi): Perhaps this should take/generate the peerKey outside of an initialized identity.
   constructor(
     private readonly _metadataStore: MetadataStore,
-    private readonly _feedStore: FeedStore<FeedMessage>,
     private readonly _keyring: Keyring,
-    private readonly _networkManager: NetworkManager,
-    private readonly _modelFactory: ModelFactory
+    private readonly _spaceManager: SpaceManager
   ) {}
 
   get identity() {
@@ -176,43 +166,40 @@ export class IdentityManager {
       spaceRecord: identityRecord.haloSpace,
       swarmIdentity: {
         peerKey: identityRecord.deviceKey,
-        credentialProvider: MOCK_AUTH_PROVIDER,
-        credentialAuthenticator: MOCK_AUTH_VERIFIER
-      }
+        credentialProvider: createHaloAuthProvider(
+          createCredentialSignerWithKey(this._keyring, identityRecord.deviceKey)
+        ),
+        credentialAuthenticator: deferFunction(() => identity.authVerifier.verifier)
+      },
+      identityKey: identityRecord.identityKey
     });
-
-    log('done', { identityKey: identityRecord.identityKey });
-    return new Identity({
+    const identity: Identity = new Identity({
       space,
       signer: this._keyring,
       identityKey: identityRecord.identityKey,
       deviceKey: identityRecord.deviceKey
     });
-  }
-
-  private async _constructSpace({ spaceRecord, swarmIdentity }: ConstructSpaceParams) {
-    const controlFeed = await this._feedStore.openFeed(spaceRecord.writeControlFeedKey, { writable: true });
-    const dataFeed = await this._feedStore.openFeed(spaceRecord.writeDataFeedKey, { writable: true });
-
-    // The genesis feed will be the same as the control feed if the space was created by the local agent.
-    // NOTE: Must be initialized after writable feeds so that it is in a writable state.
-    const genesisFeed = await this._feedStore.openFeed(spaceRecord.genesisFeedKey);
+    log('done', { identityKey: identityRecord.identityKey });
 
-    const protocol = new SpaceProtocol({
-      topic: spaceRecord.spaceKey,
-      identity: swarmIdentity,
-      networkManager: this._networkManager
-    });
+    return identity;
+  }
 
-    return new Space({
-      spaceKey: spaceRecord.spaceKey,
-      protocol,
-      genesisFeed,
-      controlFeed,
-      dataFeed,
-      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey),
-      databaseFactory: async ({ databaseBackend }) =>
-        new Database(this._modelFactory, databaseBackend, swarmIdentity.peerKey)
+  private async _constructSpace({ spaceRecord, swarmIdentity, identityKey }: ConstructSpaceParams) {
+    return this._spaceManager.constructSpace({
+      metadata: {
+        key: spaceRecord.spaceKey,
+        genesisFeedKey: spaceRecord.genesisFeedKey,
+        controlFeedKey: spaceRecord.writeControlFeedKey,
+        dataFeedKey: spaceRecord.writeDataFeedKey
+      },
+      dataPipelineControllerProvider: () => new NoopDataPipelineController(),
+      swarmIdentity,
+      presence: new Presence({
+        localPeerId: swarmIdentity.peerKey,
+        announceInterval: 1_000,
+        offlineTimeout: 30_000,
+        identityKey
+      })
     });
   }
 }

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

@@ -4,8 +4,15 @@
 
 import expect from 'expect';
 
-import { CredentialGenerator, verifyCredential, createCredentialSignerWithKey } from '@dxos/credentials';
-import { valueEncoding, Database, MOCK_AUTH_PROVIDER, MOCK_AUTH_VERIFIER, Space, SpaceProtocol } from '@dxos/echo-db';
+import { CredentialGenerator, verifyCredential } from '@dxos/credentials';
+import {
+  MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER,
+  NoopDataPipelineController,
+  Space,
+  SpaceProtocol,
+  valueEncoding
+} from '@dxos/echo-db';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
@@ -14,14 +21,11 @@ import { MemoryTransportFactory, NetworkManager } from '@dxos/network-manager';
 import { 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 { describe, test, afterTest } from '@dxos/test';
+import { Presence } from '@dxos/teleport-extension-presence';
+import { afterTest, describe, test } from '@dxos/test';
 
-import { createDefaultModelFactory } from '../services';
-import { createHaloAuthProvider, createHaloAuthVerifier } from './authenticator';
 import { Identity } from './identity';
 
-const modelFactory = createDefaultModelFactory();
-
 describe('identity/identity', () => {
   test('create', async () => {
     const keyring = new Keyring();
@@ -49,14 +53,20 @@ describe('identity/identity', () => {
 
     const protocol = new SpaceProtocol({
       topic: spaceKey,
-      identity: {
-        peerKey: identityKey,
-        credentialProvider: createHaloAuthProvider(createCredentialSignerWithKey(keyring, deviceKey)),
-        credentialAuthenticator: createHaloAuthVerifier(() => identity.authorizedDeviceKeys)
+      swarmIdentity: {
+        peerKey: deviceKey,
+        credentialProvider: MOCK_AUTH_PROVIDER,
+        credentialAuthenticator: MOCK_AUTH_VERIFIER
       },
       networkManager: new NetworkManager({
         signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
         transportFactory: MemoryTransportFactory
+      }),
+      presence: new Presence({
+        localPeerId: deviceKey,
+        announceInterval: 30,
+        offlineTimeout: 200,
+        identityKey
       })
     });
 
@@ -67,7 +77,7 @@ describe('identity/identity', () => {
       controlFeed,
       dataFeed,
       feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-      databaseFactory: async ({ databaseBackend }) => new Database(modelFactory, databaseBackend, deviceKey)
+      dataPipelineControllerProvider: () => new NoopDataPipelineController()
     });
 
     const identity = new Identity({
@@ -120,6 +130,7 @@ describe('identity/identity', () => {
     const signalContext = new MemorySignalManagerContext();
 
     let spaceKey: PublicKey;
+    let identityKey: PublicKey;
     let genesisFeedKey: PublicKey;
     let identity1: Identity;
     let identity2: Identity;
@@ -129,7 +140,7 @@ describe('identity/identity', () => {
     //
     {
       const keyring = new Keyring();
-      const identityKey = await keyring.createKey();
+      identityKey = await keyring.createKey();
       const deviceKey = await keyring.createKey();
       spaceKey = await keyring.createKey();
 
@@ -155,7 +166,7 @@ describe('identity/identity', () => {
 
       const protocol = new SpaceProtocol({
         topic: spaceKey,
-        identity: {
+        swarmIdentity: {
           peerKey: deviceKey,
           credentialProvider: MOCK_AUTH_PROVIDER, // createHaloAuthProvider(createCredentialSignerWithKey(keyring, device_key)),
           credentialAuthenticator: MOCK_AUTH_VERIFIER // createHaloAuthVerifier(() => identity.authorizedDeviceKeys),
@@ -163,6 +174,12 @@ describe('identity/identity', () => {
         networkManager: new NetworkManager({
           signalManager: new MemorySignalManager(signalContext),
           transportFactory: MemoryTransportFactory
+        }),
+        presence: new Presence({
+          localPeerId: deviceKey,
+          announceInterval: 30,
+          offlineTimeout: 200,
+          identityKey
         })
       });
 
@@ -173,7 +190,7 @@ describe('identity/identity', () => {
         controlFeed,
         dataFeed,
         feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-        databaseFactory: async ({ databaseBackend }) => new Database(modelFactory, databaseBackend, deviceKey)
+        dataPipelineControllerProvider: () => new NoopDataPipelineController()
       });
 
       const identity = (identity1 = new Identity({
@@ -236,7 +253,7 @@ describe('identity/identity', () => {
 
       const protocol = new SpaceProtocol({
         topic: spaceKey,
-        identity: {
+        swarmIdentity: {
           peerKey: deviceKey,
           credentialProvider: MOCK_AUTH_PROVIDER, // createHaloAuthProvider(createCredentialSignerWithKey(keyring, device_key)),
           credentialAuthenticator: MOCK_AUTH_VERIFIER // createHaloAuthVerifier(() => identity.authorizedDeviceKeys),
@@ -244,6 +261,12 @@ describe('identity/identity', () => {
         networkManager: new NetworkManager({
           signalManager: new MemorySignalManager(signalContext),
           transportFactory: MemoryTransportFactory
+        }),
+        presence: new Presence({
+          localPeerId: deviceKey,
+          announceInterval: 30,
+          offlineTimeout: 200,
+          identityKey
         })
       });
 
@@ -254,7 +277,7 @@ describe('identity/identity', () => {
         controlFeed,
         dataFeed,
         feedProvider: (feedKey) => feedStore.openFeed(feedKey),
-        databaseFactory: async ({ databaseBackend }) => new Database(modelFactory, databaseBackend, deviceKey)
+        dataPipelineControllerProvider: () => new NoopDataPipelineController()
       });
 
       const identity = (identity2 = new Identity({

package/src/packlets/identity/identity.ts

@@ -13,8 +13,7 @@ import {
   ProfileStateMachine
 } from '@dxos/credentials';
 import { Signer } from '@dxos/crypto';
-import { failUndefined } from '@dxos/debug';
-import { Database, Space } from '@dxos/echo-db';
+import { Space } from '@dxos/echo-db';
 import { writeMessages } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -23,6 +22,13 @@ import { AdmittedFeed, ProfileDocument } from '@dxos/protocols/proto/dxos/halo/c
 import { HaloAdmissionCredentials } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { ComplexSet } from '@dxos/util';
 
+import { HaloAuthVerifier } from './authenticator';
+
+/**
+ * Timeout for the device to be added to the trusted set during auth.
+ */
+const AUTH_TIMEOUT = 30000;
+
 export type IdentityParams = {
   identityKey: PublicKey;
   deviceKey: PublicKey;
@@ -34,10 +40,11 @@ export type IdentityParams = {
  * Agent identity manager, which includes the agent's Halo space.
  */
 export class Identity {
-  private readonly _space: Space;
+  public readonly space: Space;
   private readonly _signer: Signer;
   private readonly _deviceStateMachine: DeviceStateMachine;
   private readonly _profileStateMachine: ProfileStateMachine;
+  public readonly authVerifier: HaloAuthVerifier;
 
   public readonly identityKey: PublicKey;
   public readonly deviceKey: PublicKey;
@@ -45,7 +52,7 @@ export class Identity {
   public readonly stateUpdate = new Event();
 
   constructor({ space, signer, identityKey, deviceKey }: IdentityParams) {
-    this._space = space;
+    this.space = space;
     this._signer = signer;
 
     this.identityKey = identityKey;
@@ -55,12 +62,18 @@ export class Identity {
     this._profileStateMachine = new ProfileStateMachine(this.identityKey);
 
     // Process halo-specific credentials.
-    this._space.onCredentialProcessed.set(async (credential) => {
+    this.space.onCredentialProcessed.set(async (credential) => {
       // Save device keychain credential when processed by the space state machine.
       await this._deviceStateMachine.process(credential);
       await this._profileStateMachine.process(credential);
       this.stateUpdate.emit();
     });
+
+    this.authVerifier = new HaloAuthVerifier({
+      trustedDevicesProvider: () => this.authorizedDeviceKeys,
+      update: this.stateUpdate,
+      authTimeout: AUTH_TIMEOUT
+    });
   }
 
   // TODO(burdon): Expose state object?
@@ -69,11 +82,12 @@ export class Identity {
   }
 
   async open() {
-    await this._space.open();
+    await this.space.open();
   }
 
   async close() {
-    await this._space.close();
+    await this.authVerifier.close();
+    await this.space.close();
   }
 
   async ready() {
@@ -90,26 +104,22 @@ export class Identity {
    * @test-only
    */
   get controlPipeline() {
-    return this._space.controlPipeline;
+    return this.space.controlPipeline;
   }
 
   get haloSpaceKey() {
-    return this._space.key;
+    return this.space.key;
   }
 
   get haloGenesisFeedKey() {
-    return this._space.genesisFeedKey;
-  }
-
-  get haloDatabase(): Database {
-    return this._space.database ?? failUndefined();
+    return this.space.genesisFeedKey;
   }
 
   getAdmissionCredentials(): HaloAdmissionCredentials {
     return {
       deviceKey: this.deviceKey,
-      controlFeedKey: this._space.controlFeedKey,
-      dataFeedKey: this._space.dataFeedKey
+      controlFeedKey: this.space.controlFeedKey,
+      dataFeedKey: this.space.dataFeedKey
     };
   }
 

package/src/packlets/invitations/halo-invitations-handler.ts

@@ -20,7 +20,7 @@ import {
   HaloAdmissionOffer,
   HaloHostService
 } from '@dxos/protocols/proto/dxos/halo/invitations';
-import { ExtensionContext } from '@dxos/teleport';
+import { ExtensionContext, RpcExtension } from '@dxos/teleport';
 
 import { IdentityManager } from '../identity';
 import {
@@ -32,7 +32,6 @@ import {
   ON_CLOSE_DELAY
 } from './invitations';
 import { AbstractInvitationsHandler, InvitationsOptions } from './invitations-handler';
-import { RpcExtension } from './rpc-extension';
 
 /**
  * Handles the life-cycle of Halo invitations between peers.

package/src/packlets/invitations/space-invitations-handler.test.ts

@@ -24,15 +24,15 @@ describe('services/space-invitations-handler', () => {
   test('genesis', async () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
-    const space = await peer.spaceManager!.createSpace();
+    const space = await peer.dataSpaceManager!.createSpace();
     expect(space.database).not.to.be.undefined;
-    expect(peer.spaceManager!.spaces.has(space.key)).to.be.true;
+    expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
     await space.close();
   });
 
   test('genesis with database mutations', async () => {
     const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
-    const space = await peer.spaceManager!.createSpace();
+    const space = await peer.dataSpaceManager!.createSpace();
 
     {
       const item = await space.database!.createItem<ObjectModel>({ type: 'test' });
@@ -56,7 +56,7 @@ describe('services/space-invitations-handler', () => {
     let attempt = 0;
     const authenticationCode = new Trigger<string>();
 
-    const space1 = await host.spaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace();
     const observable1 = host.spaceInvitations!.createInvitation(space1);
     observable1.subscribe({
       onConnecting: async (invitation1: Invitation) => {
@@ -98,8 +98,8 @@ describe('services/space-invitations-handler', () => {
     expect(spaceKey1).to.deep.eq(spaceKey2);
 
     {
-      const space1 = host.spaceManager!.spaces.get(spaceKey1)!;
-      const space2 = guest.spaceManager!.spaces.get(spaceKey2)!;
+      const space1 = host.dataSpaceManager!.spaces.get(spaceKey1)!;
+      const space2 = guest.dataSpaceManager!.spaces.get(spaceKey2)!;
       expect(space1).not.to.be.undefined;
       expect(space2).not.to.be.undefined;
 
@@ -117,7 +117,7 @@ describe('services/space-invitations-handler', () => {
     const connecting1 = new Trigger<Invitation>(); // peer 1 connected.
     const connecting2 = new Trigger<Invitation>(); // peer 2 connected.
 
-    const space1 = await host.spaceManager!.createSpace();
+    const space1 = await host.dataSpaceManager!.createSpace();
     const observable1 = await host.spaceInvitations!.createInvitation(space1);
     observable1.subscribe({
       onConnecting: async (invitation1: Invitation) => {