@dxos/client-services 0.6.11 → 0.6.12-main.5a87ad5

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

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

package/src/packlets/identity/identity.ts

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

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

@@ -2,19 +2,20 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test, onTestFinished } from 'vitest';
 
 import { asyncChain } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { describe, test, afterTest } from '@dxos/test';
 
 import { type ServiceContext } from '../services';
 import { createPeers, createServiceContext, performInvitation } from '../testing';
 
 const closeAfterTest = async (peer: ServiceContext) => {
-  afterTest(() => peer.close());
+  onTestFinished(async () => {
+    await peer.close();
+  });
   return peer;
 };
 
@@ -22,7 +23,9 @@ describe('services/device', () => {
   test('creates identity', async () => {
     const peer = await createServiceContext();
     await peer.open(new Context());
-    afterTest(() => peer.close());
+    onTestFinished(async () => {
+      await peer.close();
+    });
 
     const identity = await peer.createIdentity();
     expect(identity).not.to.be.undefined;

package/src/packlets/invitations/invitation-host-extension.ts

@@ -106,13 +106,11 @@ export class InvitationHostExtension extends RpcExtension<
 
         introduce: async (request) => {
           const { profile, invitationId } = request;
-
           const traceId = PublicKey.random().toHex();
           log.trace('dxos.sdk.invitation-handler.host.introduce', trace.begin({ id: traceId }));
 
           const invitation = this._requireActiveInvitation();
           this._assertInvitationState(Invitation.State.CONNECTED);
-
           if (invitationId !== invitation?.invitationId) {
             log.warn('incorrect invitationId', { expected: invitation.invitationId, actual: invitationId });
             this._callbacks.onError(new Error('Incorrect invitationId.'));
@@ -126,7 +124,6 @@ export class InvitationHostExtension extends RpcExtension<
           log('guest introduced themselves', { guestProfile: profile });
           this.guestProfile = profile;
           this._callbacks.onStateUpdate(Invitation.State.READY_FOR_AUTHENTICATION);
-
           this._challenge =
             invitation.authMethod === Invitation.AuthMethod.KNOWN_PUBLIC_KEY ? randomBytes(32) : undefined;
 

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

@@ -2,13 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
+import { beforeEach, onTestFinished, describe, expect, test } from 'vitest';
 
 import { type PushStream, sleep, Trigger, waitForCondition } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { openAndClose } from '@dxos/test-utils';
 import { range } from '@dxos/util';
 
 import { type InvitationProtocol } from './invitation-protocol';
@@ -34,6 +34,7 @@ type StateUpdateSink = PushStream<Invitation> & {
 
 describe('InvitationHandler', () => {
   let testBuilder: TestBuilder;
+
   beforeEach(() => {
     testBuilder = new TestBuilder();
   });
@@ -163,7 +164,7 @@ describe('InvitationHandler', () => {
       expect(guest.ctx.disposed).to.be.true;
     });
 
-    test('guest gives up after trying with three hosts', async () => {
+    test('guest gives up after trying with three hosts', { timeout: 20_000 }, async () => {
       const hosts: PeerSetup[] = [await createPeer()];
       const [host] = hosts;
       const invitation = await createInvitation(host, { multiUse: true });
@@ -181,7 +182,7 @@ describe('InvitationHandler', () => {
 
       await sleep(10);
       expect(guest.sink.lastState).to.eq(Invitation.State.ERROR);
-    }).timeout(20_000);
+    });
 
     test('single host - many guests', async () => {
       const hosts: PeerSetup[] = [await createPeer()];
@@ -261,7 +262,9 @@ describe('InvitationHandler', () => {
     });
     const protocol = new SpaceInvitationProtocol(peer.dataSpaceManager, peer.identity, peer.keyring, spaceKey);
     const ctx = new Context();
-    afterTest(() => ctx.dispose());
+    onTestFinished(async () => {
+      await ctx.dispose();
+    });
     const sink = newStateUpdateSink();
     return { ctx, sink, peer, protocol, handler: invitationHandler, spaceKey };
   };
@@ -269,14 +272,18 @@ describe('InvitationHandler', () => {
   const hostInvitation = async (setup: PeerSetup, invitation: Invitation) => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    afterTest(() => setup.ctx.dispose());
+    onTestFinished(async () => {
+      await setup.ctx.dispose();
+    });
     setup.handler.handleInvitationFlow(setup.ctx, setup.sink, setup.protocol, invitation);
   };
 
   const acceptInvitation = async (setup: PeerSetup, invitation: Invitation): Promise<Trigger<string>> => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    afterTest(() => setup.ctx.dispose());
+    onTestFinished(async () => {
+      await setup.ctx.dispose();
+    });
     const authCodeInput = new Trigger<string>();
     setup.handler.acceptInvitation(setup.ctx, setup.sink, setup.protocol, invitation, authCodeInput);
     return authCodeInput;

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

@@ -463,7 +463,7 @@ export class InvitationsHandler {
         oldState: stateToString(invitation.state),
       });
     } else {
-      log.info('invitation state update', {
+      log('invitation state update', {
         actor: actor?.constructor.name,
         newState: stateToString(newState),
         oldState: stateToString(invitation.state),