@dxos/client-services 0.1.35 → 0.1.36

package/src/packlets/invitations/invitations-service.ts

@@ -4,92 +4,98 @@
 
 import assert from 'node:assert';
 
-import { TimeoutError } from '@dxos/async';
-import {
-  AuthenticatingInvitationObservable,
-  CancellableInvitationObservable,
-  InvitationsService,
-  InvitationsHandler,
-  InvitationsOptions
-} from '@dxos/client';
+import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from '@dxos/client';
 import { Stream } from '@dxos/codec-protobuf';
 import { log } from '@dxos/log';
-import { AuthenticationRequest, Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { Provider } from '@dxos/util';
+import { AuthenticationRequest, Invitation, InvitationsService } from '@dxos/protocols/proto/dxos/client/services';
 
-import { IdentityManager } from '../identity';
+import { InvitationProtocol } from './invitation-protocol';
+import { InvitationsHandler } from './invitations-handler';
 
 /**
  * Adapts invitation service observable to client/service stream.
  */
-export abstract class AbstractInvitationsService<T = void> implements InvitationsService {
+export class InvitationsServiceImpl implements InvitationsService {
   private readonly _createInvitations = new Map<string, CancellableInvitationObservable>();
   private readonly _acceptInvitations = new Map<string, AuthenticatingInvitationObservable>();
 
-  // prettier-ignore
-  protected constructor (
-    private readonly _identityManager: IdentityManager,
-    private readonly _getInvitationsHandler: Provider<InvitationsHandler<T>>
+  constructor(
+    private readonly _invitationsHandler: InvitationsHandler,
+    private readonly _getHandler: (invitation: Invitation) => InvitationProtocol
   ) {}
 
   // TODO(burdon): Guest/host label.
   getLoggingContext() {
     return {
-      deviceKey: this._identityManager.identity?.deviceKey
+      // deviceKey: this._identityManager.identity?.deviceKey
     };
   }
 
-  abstract getContext(invitation: Invitation): T;
-
   createInvitation(invitation: Invitation): Stream<Invitation> {
     return new Stream<Invitation>(({ next, close }) => {
-      const invitationsHandler: InvitationsHandler<T> = this._getInvitationsHandler();
-      const context = this.getContext(invitation);
+      const handler = this._getHandler(invitation);
       log('stream opened', this.getLoggingContext());
 
       let invitationId: string;
-      const { type, swarmKey, authMethod } = invitation;
-      const observable = invitationsHandler.createInvitation(context, { type, swarmKey, authMethod });
-      observable.subscribe({
-        onConnecting: (invitation) => {
-          assert(invitation.invitationId);
-          invitationId = invitation.invitationId;
-          this._createInvitations.set(invitation.invitationId, observable);
-          invitation.state = Invitation.State.CONNECTING;
-          next(invitation);
-        },
-        onConnected: (invitation) => {
-          assert(invitation.invitationId);
-          invitation.state = Invitation.State.CONNECTED;
-          next(invitation);
-        },
-        onAuthenticating: (invitation) => {
-          assert(invitation.invitationId);
-          invitation.state = Invitation.State.AUTHENTICATING;
-          next(invitation);
-        },
-        onSuccess: (invitation) => {
-          assert(invitation.invitationId);
-          invitation.state = Invitation.State.SUCCESS;
-          next(invitation);
-          close();
+      const observable = this._invitationsHandler.createInvitation(handler, invitation);
+      observable.subscribe(
+        (invitation) => {
+          switch (invitation.state) {
+            case Invitation.State.CONNECTING: {
+              assert(invitation.invitationId);
+              invitationId = invitation.invitationId;
+              this._createInvitations.set(invitation.invitationId, observable);
+              invitation.state = Invitation.State.CONNECTING;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.CONNECTED: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.CONNECTED;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.READY_FOR_AUTHENTICATION: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.READY_FOR_AUTHENTICATION;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.AUTHENTICATING: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.AUTHENTICATING;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.SUCCESS: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.SUCCESS;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.CANCELLED: {
+              assert(invitationId);
+              invitation.invitationId = invitationId;
+              invitation.state = Invitation.State.CANCELLED;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.TIMEOUT: {
+              assert(invitationId);
+              invitation.invitationId = invitationId;
+              invitation.state = Invitation.State.TIMEOUT;
+              next(invitation);
+              break;
+            }
+          }
         },
-        onCancelled: () => {
-          assert(invitationId);
-          invitation.invitationId = invitationId;
-          invitation.state = Invitation.State.CANCELLED;
-          next(invitation);
-          close();
-        },
-        onTimeout: (err: TimeoutError) => {
-          invitation.state = Invitation.State.TIMEOUT;
+        (err: Error) => {
           close(err);
         },
-        onError: (err: any) => {
-          invitation.state = Invitation.State.ERROR;
-          close(err);
+        () => {
+          close();
         }
-      });
+      );
 
       return (err?: Error) => {
         const context = this.getLoggingContext();
@@ -104,52 +110,70 @@ export abstract class AbstractInvitationsService<T = void> implements Invitation
     });
   }
 
-  acceptInvitation(invitation: Invitation, options?: InvitationsOptions): Stream<Invitation> {
+  acceptInvitation(invitation: Invitation): Stream<Invitation> {
     return new Stream<Invitation>(({ next, close }) => {
       log('stream opened', this.getLoggingContext());
-      const invitationsHandler = this._getInvitationsHandler();
+      const handler = this._getHandler(invitation);
 
       let invitationId: string;
-      const observable = invitationsHandler.acceptInvitation(invitation, options);
-      observable.subscribe({
-        onConnecting: (invitation) => {
-          assert(invitation.invitationId);
-          invitationId = invitation.invitationId;
-          this._acceptInvitations.set(invitation.invitationId, observable);
-          invitation.state = Invitation.State.CONNECTING;
-          next(invitation);
-        },
-        onConnected: (invitation) => {
-          assert(invitation.invitationId);
-          invitation.state = Invitation.State.CONNECTED;
-          next(invitation);
+      const observable = this._invitationsHandler.acceptInvitation(handler, invitation);
+      observable.subscribe(
+        (invitation) => {
+          switch (invitation.state) {
+            case Invitation.State.CONNECTING: {
+              assert(invitation.invitationId);
+              invitationId = invitation.invitationId;
+              this._acceptInvitations.set(invitation.invitationId, observable);
+              invitation.state = Invitation.State.CONNECTING;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.CONNECTED: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.CONNECTED;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.READY_FOR_AUTHENTICATION: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.READY_FOR_AUTHENTICATION;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.AUTHENTICATING: {
+              assert(invitation.invitationId);
+              invitation.state = Invitation.State.AUTHENTICATING;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.SUCCESS: {
+              invitation.state = Invitation.State.SUCCESS;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.CANCELLED: {
+              assert(invitationId);
+              invitation.invitationId = invitationId;
+              invitation.state = Invitation.State.CANCELLED;
+              next(invitation);
+              break;
+            }
+            case Invitation.State.TIMEOUT: {
+              assert(invitationId);
+              invitation.invitationId = invitationId;
+              invitation.state = Invitation.State.TIMEOUT;
+              next(invitation);
+              break;
+            }
+          }
         },
-        onAuthenticating: (invitation) => {
-          assert(invitation.invitationId);
-          invitation.state = Invitation.State.AUTHENTICATING;
-          next(invitation);
-        },
-        onSuccess: (invitation) => {
-          invitation.state = Invitation.State.SUCCESS;
-          next(invitation);
-          close();
-        },
-        onCancelled: () => {
-          assert(invitationId);
-          invitation.invitationId = invitationId;
-          invitation.state = Invitation.State.CANCELLED;
-          next(invitation);
-          close();
-        },
-        onTimeout: (err: TimeoutError) => {
-          invitation.state = Invitation.State.TIMEOUT;
+        (err: Error) => {
           close(err);
         },
-        onError: (err: any) => {
-          invitation.state = Invitation.State.ERROR;
-          close(err);
+        () => {
+          close();
         }
-      });
+      );
 
       return (err?: Error) => {
         const context = this.getLoggingContext();
@@ -164,24 +188,23 @@ export abstract class AbstractInvitationsService<T = void> implements Invitation
     });
   }
 
-  async authenticate({ invitationId, authenticationCode }: AuthenticationRequest): Promise<void> {
+  async authenticate({ invitationId, authCode }: AuthenticationRequest): Promise<void> {
     log('authenticating...');
     assert(invitationId);
     const observable = this._acceptInvitations.get(invitationId);
     if (!observable) {
       log.warn('invalid invitation', { invitationId });
     } else {
-      await observable.authenticate(authenticationCode);
+      await observable.authenticate(authCode);
     }
   }
 
-  async cancelInvitation(invitation: Invitation): Promise<void> {
+  async cancelInvitation({ invitationId }: { invitationId: string }): Promise<void> {
     log('cancelling...');
-    assert(invitation.invitationId);
-    const observable =
-      this._createInvitations.get(invitation.invitationId) ?? this._acceptInvitations.get(invitation.invitationId);
+    assert(invitationId);
+    const observable = this._createInvitations.get(invitationId) ?? this._acceptInvitations.get(invitationId);
     if (!observable) {
-      log.warn('invalid invitation', { invitationId: invitation.invitationId });
+      log.warn('invalid invitation', { invitationId });
     } else {
       await observable?.cancel();
     }

package/src/packlets/invitations/space-invitation-protocol.test.ts

@@ -0,0 +1,221 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect } from 'chai';
+
+import { asyncChain, Trigger } from '@dxos/async';
+import { raise } from '@dxos/debug';
+import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { afterTest, describe, test } from '@dxos/test';
+
+import { ServiceContext } from '../services';
+import { createIdentity, createPeers, syncItemsLocal } from '../testing';
+import { performInvitation } from '../testing/invitation-utils';
+
+const closeAfterTest = async (peer: ServiceContext) => {
+  afterTest(() => peer.close());
+  return peer;
+};
+
+describe('services/space-invitations-protocol', () => {
+  test('genesis', async () => {
+    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+
+    const space = await peer.dataSpaceManager!.createSpace();
+    expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
+
+    await space.close();
+  });
+
+  test('genesis & ready', async () => {
+    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+
+    const space = await peer.dataSpaceManager!.createSpace();
+    expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
+
+    await peer.dataSpaceManager?.waitUntilSpaceReady(space.key);
+    await space.close();
+  });
+
+  test('genesis with database mutations', async () => {
+    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+    const space = await peer.dataSpaceManager!.createSpace();
+    afterTest(() => space.close());
+
+    await testLocalDatabase(space.dataPipeline);
+  });
+
+  test('invitation with no auth', async () => {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    const space1 = await host.dataSpaceManager!.createSpace();
+    const spaceKey = space1.key;
+
+    await Promise.all(performInvitation({ host, guest, options: { kind: Invitation.Kind.SPACE, spaceKey } }));
+
+    {
+      const space1 = host.dataSpaceManager!.spaces.get(spaceKey)!;
+      const space2 = guest.dataSpaceManager!.spaces.get(spaceKey)!;
+      expect(space1).not.to.be.undefined;
+      expect(space2).not.to.be.undefined;
+
+      await host.dataSpaceManager?.waitUntilSpaceReady(space1.key);
+      await guest.dataSpaceManager?.waitUntilSpaceReady(space2.key);
+
+      await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
+
+      await space1.close();
+      await space2.close();
+    }
+  });
+
+  test('creates and accepts invitation with retry', async () => {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    let attempt = 0;
+
+    const space1 = await host.dataSpaceManager!.createSpace();
+
+    const [{ invitation: invitation1 }, { invitation: invitation2 }] = await Promise.all(
+      performInvitation({
+        host,
+        guest,
+        options: { kind: Invitation.Kind.SPACE, spaceKey: space1.key },
+        hooks: {
+          guest: {
+            onReady: (invitation) => {
+              if (attempt === 0) {
+                // Force retry.
+                void invitation.authenticate('000000');
+                attempt++;
+                return true;
+              }
+
+              return false;
+            }
+          }
+        }
+      })
+    );
+
+    expect(attempt).to.eq(1);
+    expect(invitation1?.spaceKey).to.exist;
+    expect(invitation2?.spaceKey).to.exist;
+    expect(invitation1?.spaceKey).to.deep.eq(invitation2?.spaceKey);
+
+    {
+      const space1 = host.dataSpaceManager!.spaces.get(invitation1!.spaceKey!)!;
+      const space2 = guest.dataSpaceManager!.spaces.get(invitation2!.spaceKey!)!;
+      expect(space1).not.to.be.undefined;
+      expect(space2).not.to.be.undefined;
+
+      await host.dataSpaceManager?.waitUntilSpaceReady(space1.key);
+      await guest.dataSpaceManager?.waitUntilSpaceReady(space2.key);
+
+      await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
+
+      await space1.close();
+      await space2.close();
+    }
+
+    expect(
+      guest.identityManager.identity?.space.spaceState.getCredentialsOfType('dxos.halo.credentials.SpaceMember').length
+    ).to.equal(2); // own halo + newly joined space.
+  });
+
+  test('cancels invitation', async () => {
+    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+
+    const hostConnected = new Trigger<Invitation>();
+    const guestConnected = new Trigger<Invitation>();
+
+    const space1 = await host.dataSpaceManager!.createSpace();
+
+    const invitationPromises = performInvitation({
+      host,
+      guest,
+      options: { kind: Invitation.Kind.SPACE, spaceKey: space1.key },
+      hooks: {
+        host: {
+          onConnecting: (invitation) => {
+            hostConnected.wake(invitation.get());
+          },
+          onConnected: (invitation) => {
+            void invitation.cancel();
+            return true;
+          },
+          onSuccess: () => raise(new Error('invitation success'))
+        },
+        guest: {
+          onConnecting: (invitation) => {
+            guestConnected.wake(invitation.get());
+          }
+        }
+      }
+    });
+
+    const { swarmKey: swarmKey1 } = await hostConnected.wait();
+    const { swarmKey: swarmKey2 } = await guestConnected.wait();
+    expect(swarmKey1).to.deep.eq(swarmKey2);
+
+    const [{ invitation: invitation1 }, { error }] = await Promise.all(invitationPromises);
+    expect(invitation1?.state).to.eq(Invitation.State.CANCELLED);
+    expect(error).to.exist;
+
+    await space1.close();
+  });
+
+  // TODO(burdon): Flaky.
+  // test.skip('test multi-use invitation', async () => {
+  //   const GUEST_COUNT = 3;
+  //   const [host, ...guests] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(
+  //     createPeers(GUEST_COUNT + 1)
+  //   );
+
+  //   const hostSpace = await host.dataSpaceManager!.createSpace();
+  //   const swarmKey = PublicKey.random();
+  //   const hostObservable = await host.spaceInvitations!.createInvitation(hostSpace, {
+  //     swarmKey,
+  //     type: Invitation.Type.MULTIUSE_TESTING
+  //   });
+
+  //   const [done, count] = latch({ count: GUEST_COUNT });
+  //   hostObservable.subscribe({
+  //     onConnecting: async (invitation2: Invitation) => {},
+  //     onConnected: async (invitation2: Invitation) => {},
+  //     onSuccess: () => {
+  //       count();
+  //     },
+  //     onCancelled: () => {},
+  //     onTimeout: (err: Error) => raise(err),
+  //     onError: (err: Error) => raise(err)
+  //   });
+
+  //   await Promise.all(
+  //     range(GUEST_COUNT).map(async (idx) => {
+  //       const observable = await guests[idx].spaceInvitations!.acceptInvitation({
+  //         swarmKey,
+  //         type: Invitation.Type.MULTIUSE_TESTING
+  //       });
+  //       const success = new Trigger();
+  //       observable.subscribe({
+  //         onConnecting: async (invitation2: Invitation) => {},
+  //         onConnected: async (invitation2: Invitation) => {},
+  //         onSuccess: () => {
+  //           success.wake();
+  //         },
+  //         onCancelled: () => raise(new Error()),
+  //         onTimeout: (err: Error) => raise(err),
+  //         onError: (err: Error) => raise(err)
+  //       });
+  //       await success.wait({ timeout: 300 });
+  //     })
+  //   );
+  //   await done();
+
+  //   await hostObservable.cancel();
+  //   await hostSpace.close();
+  // });
+});

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -0,0 +1,117 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import assert from 'node:assert';
+
+import { createAdmissionCredentials, getCredentialAssertion } from '@dxos/credentials';
+import { SigningContext } from '@dxos/echo-pipeline';
+import { writeMessages } from '@dxos/feed-store';
+import { Keyring } from '@dxos/keyring';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
+import { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
+import { ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { AdmissionRequest, AdmissionResponse, IntroductionRequest } from '@dxos/protocols/proto/dxos/halo/invitations';
+
+import { DataSpaceManager } from '../spaces';
+import { InvitationProtocol } from './invitation-protocol';
+
+export class SpaceInvitationProtocol implements InvitationProtocol {
+  constructor(
+    private readonly _spaceManager: DataSpaceManager,
+    private readonly _signingContext: SigningContext,
+    private readonly _keyring: Keyring,
+    private readonly _spaceKey?: PublicKey
+  ) {}
+
+  toJSON(): object {
+    return {
+      deviceKey: this._signingContext.deviceKey,
+      spaceKey: this._spaceKey
+    };
+  }
+
+  getInvitationContext(): Partial<Invitation> & Pick<Invitation, 'kind'> {
+    return {
+      kind: Invitation.Kind.SPACE,
+      spaceKey: this._spaceKey
+    };
+  }
+
+  async admit(request: AdmissionRequest, guestProfile?: ProfileDocument | undefined): Promise<AdmissionResponse> {
+    assert(this._spaceKey);
+    const space = await this._spaceManager.spaces.get(this._spaceKey);
+    assert(space);
+
+    assert(request.space);
+    const { identityKey, deviceKey } = request.space;
+
+    log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
+    // TODO(burdon): Check if already admitted.
+    const credentials: FeedMessage.Payload[] = await createAdmissionCredentials(
+      this._signingContext.credentialSigner,
+      identityKey,
+      space.key,
+      space.inner.genesisFeedKey,
+      guestProfile
+    );
+
+    // TODO(dmaretskyi): Refactor.
+    assert(credentials[0].credential);
+    const spaceMemberCredential = credentials[0].credential.credential;
+    assert(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+
+    await writeMessages(space.inner.controlPipeline.writer, credentials);
+
+    return {
+      space: {
+        credential: spaceMemberCredential,
+        controlTimeframe: space.inner.controlPipeline.state.timeframe,
+        dataTimeframe: space.dataPipeline.pipelineState?.timeframe
+      }
+    };
+  }
+
+  createIntroduction(): IntroductionRequest {
+    return {
+      profile: this._signingContext.profile
+    };
+  }
+
+  async createAdmissionRequest(): Promise<AdmissionRequest> {
+    // Generate a pair of keys for our feeds.
+    const controlFeedKey = await this._keyring.createKey();
+    const dataFeedKey = await this._keyring.createKey();
+
+    return {
+      space: {
+        identityKey: this._signingContext.identityKey,
+        deviceKey: this._signingContext.deviceKey,
+        controlFeedKey,
+        dataFeedKey
+      }
+    };
+  }
+
+  async accept(response: AdmissionResponse): Promise<Partial<Invitation>> {
+    assert(response.space);
+    const { credential, controlTimeframe, dataTimeframe } = response.space;
+    const assertion = getCredentialAssertion(credential);
+    assert(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
+    assert(credential.subject.id.equals(this._signingContext.identityKey));
+
+    // Create local space.
+    await this._spaceManager.acceptSpace({
+      spaceKey: assertion.spaceKey,
+      genesisFeedKey: assertion.genesisFeedKey,
+      controlTimeframe,
+      dataTimeframe
+    });
+
+    await this._signingContext.recordCredential(credential);
+
+    return { spaceKey: assertion.spaceKey };
+  }
+}

package/src/packlets/services/service-context.test.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Invitation } from '@dxos/client';
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { describe, test } from '@dxos/test';
 
@@ -16,7 +17,7 @@ describe('services/ServiceContext', () => {
     const space1 = await device1.dataSpaceManager!.createSpace();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
+    await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
@@ -29,7 +30,7 @@ describe('services/ServiceContext', () => {
     await device1.createIdentity();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
+    await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
     const space1 = await device1.dataSpaceManager!.createSpace();
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
@@ -43,12 +44,18 @@ describe('services/ServiceContext', () => {
     await device1.createIdentity();
 
     const device2 = createServiceContext({ signalContext: networkContext });
-    await performInvitation(device1.deviceInvitations, device2.deviceInvitations, undefined);
+    await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
     const identity2 = createServiceContext({ signalContext: networkContext });
     await identity2.createIdentity();
     const space1 = await identity2.dataSpaceManager!.createSpace();
-    await performInvitation(identity2.spaceInvitations!, device1.spaceInvitations!, space1);
+    await Promise.all(
+      performInvitation({
+        host: identity2,
+        guest: device1,
+        options: { kind: Invitation.Kind.SPACE, spaceKey: space1.key }
+      })
+    );
 
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);