@dxos/client-services 0.6.12-staging.e11e696 → 0.6.12

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

@@ -2,9 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import expect from 'expect';
 
-import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, verifyCredential } from '@dxos/credentials';
 import {
@@ -16,9 +15,7 @@ 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';
@@ -27,6 +24,7 @@ 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';
 
@@ -44,108 +42,16 @@ 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 identityKey = args?.identityKey ?? (await keyring.createKey());
-    const spaceKey = args?.spaceKey ?? (await keyring.createKey());
+    const spaceKey = await keyring.createKey();
 
     const feedStore = new FeedStore<FeedMessage>({
       factory: new FeedFactory<FeedMessage>({
-        root: storage.createDirectory(),
+        root: storage.createDirectory('feeds'),
         signer: keyring,
         hypercore: {
           valueEncoding,
@@ -171,7 +77,7 @@ describe('identity/identity', () => {
       },
       blobStore,
       networkManager: new SwarmNetworkManager({
-        signalManager: new MemorySignalManager(args?.signalContext ?? new MemorySignalManagerContext()),
+        signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
         transportFactory: MemoryTransportFactory,
       }),
     });
@@ -181,7 +87,7 @@ describe('identity/identity', () => {
       id: await createIdFromSpaceKey(spaceKey),
       spaceKey,
       protocol,
-      genesisFeed: args?.genesisFeedKey ? await feedStore.openFeed(args.genesisFeedKey) : controlFeed,
+      genesisFeed: controlFeed,
       feedProvider: (feedKey) => feedStore.openFeed(feedKey),
       memberKey: identityKey,
       metadataStore,
@@ -197,37 +103,242 @@ describe('identity/identity', () => {
       identityKey,
       deviceKey,
       space,
-      edgeFeatures: args?.edgeConnection && { feedReplicator: true },
-      edgeConnection: args?.edgeConnection,
     });
 
     await identity.open(new Context());
-    onTestFinished(() => identity.close(new Context()));
-    return { identity, identityKey, keyring, deviceKey, controlFeed, spaceKey, dataFeed };
-  };
+    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' });
+  });
 
-  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 },
+  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();
     }
-  };
-});
 
-type TestIdentitySetup = {
-  identity: Identity;
-  keyring: Keyring;
-  identityKey: PublicKey;
-  deviceKey: PublicKey;
-  spaceKey: PublicKey;
-  controlFeed: FeedWrapper<FeedMessage>;
-  dataFeed: FeedWrapper<FeedMessage>;
-};
+    //
+    // 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,
+        }),
+      });
+
+      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 () => {},
+      });
+      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]);
+  });
+});

package/src/packlets/identity/identity.ts

@@ -14,12 +14,10 @@ import {
 } from '@dxos/credentials';
 import { type Signer } from '@dxos/crypto';
 import { type Space } from '@dxos/echo-pipeline';
-import { type EdgeConnection } from '@dxos/edge-client';
-import { writeMessages, type FeedWrapper } from '@dxos/feed-store';
+import { writeMessages } 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,
@@ -34,7 +32,6 @@ 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;
@@ -42,9 +39,6 @@ export type IdentityParams = {
   signer: Signer;
   space: Space;
   presence?: Presence;
-
-  edgeConnection?: EdgeConnection;
-  edgeFeatures?: Runtime.Client.EdgeFeatures;
 };
 
 /**
@@ -58,8 +52,6 @@ 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;
@@ -67,15 +59,15 @@ export class Identity {
 
   public readonly stateUpdate = new Event();
 
-  constructor(params: IdentityParams) {
-    this.space = params.space;
-    this._signer = params.signer;
-    this._presence = params.presence;
+  constructor({ space, signer, identityKey, deviceKey, presence }: IdentityParams) {
+    this.space = space;
+    this._signer = signer;
+    this._presence = presence;
 
-    this.identityKey = params.identityKey;
-    this.deviceKey = params.deviceKey;
+    this.identityKey = identityKey;
+    this.deviceKey = deviceKey;
 
-    log.trace('dxos.halo.device', { deviceKey: params.deviceKey });
+    log.trace('dxos.halo.device', { deviceKey });
 
     this._deviceStateMachine = new DeviceStateMachine({
       identityKey: this.identityKey,
@@ -96,10 +88,6 @@ 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?
@@ -117,14 +105,7 @@ 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()
@@ -134,13 +115,6 @@ 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();
   }
 
@@ -177,10 +151,6 @@ export class Identity {
     return this._presence;
   }
 
-  get signer() {
-    return this._signer;
-  }
-
   /**
    * Issues credentials as identity.
    * Requires identity to be ready.
@@ -253,8 +223,4 @@ 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,20 +2,19 @@
 // Copyright 2022 DXOS.org
 //
 
-import { describe, expect, test, onTestFinished } from 'vitest';
+import { expect } from 'chai';
 
 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) => {
-  onTestFinished(async () => {
-    await peer.close();
-  });
+  afterTest(() => peer.close());
   return peer;
 };
 
@@ -23,9 +22,7 @@ describe('services/device', () => {
   test('creates identity', async () => {
     const peer = await createServiceContext();
     await peer.open(new Context());
-    onTestFinished(async () => {
-      await peer.close();
-    });
+    afterTest(() => peer.close());
 
     const identity = await peer.createIdentity();
     expect(identity).not.to.be.undefined;

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

@@ -106,11 +106,13 @@ 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.'));
@@ -124,6 +126,7 @@ 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 { beforeEach, onTestFinished, describe, expect, test } from 'vitest';
+import { expect } from 'chai';
 
 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 { openAndClose } from '@dxos/test-utils';
+import { afterTest, describe, openAndClose, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { type InvitationProtocol } from './invitation-protocol';
@@ -34,7 +34,6 @@ type StateUpdateSink = PushStream<Invitation> & {
 
 describe('InvitationHandler', () => {
   let testBuilder: TestBuilder;
-
   beforeEach(() => {
     testBuilder = new TestBuilder();
   });
@@ -164,7 +163,7 @@ describe('InvitationHandler', () => {
       expect(guest.ctx.disposed).to.be.true;
     });
 
-    test('guest gives up after trying with three hosts', { timeout: 20_000 }, async () => {
+    test('guest gives up after trying with three hosts', async () => {
       const hosts: PeerSetup[] = [await createPeer()];
       const [host] = hosts;
       const invitation = await createInvitation(host, { multiUse: true });
@@ -182,7 +181,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()];
@@ -262,9 +261,7 @@ describe('InvitationHandler', () => {
     });
     const protocol = new SpaceInvitationProtocol(peer.dataSpaceManager, peer.identity, peer.keyring, spaceKey);
     const ctx = new Context();
-    onTestFinished(async () => {
-      await ctx.dispose();
-    });
+    afterTest(() => ctx.dispose());
     const sink = newStateUpdateSink();
     return { ctx, sink, peer, protocol, handler: invitationHandler, spaceKey };
   };
@@ -272,18 +269,14 @@ describe('InvitationHandler', () => {
   const hostInvitation = async (setup: PeerSetup, invitation: Invitation) => {
     await setup.ctx.dispose();
     setup.ctx = new Context();
-    onTestFinished(async () => {
-      await setup.ctx.dispose();
-    });
+    afterTest(() => 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();
-    onTestFinished(async () => {
-      await setup.ctx.dispose();
-    });
+    afterTest(() => 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('invitation state update', {
+      log.info('invitation state update', {
         actor: actor?.constructor.name,
         newState: stateToString(newState),
         oldState: stateToString(invitation.state),