@dxos/client-services 0.6.12-main.78ddbdf → 0.6.12-main.89e9959

package/src/packlets/identity/identity.ts

@@ -177,6 +177,10 @@ export class Identity {
     return this._presence;
   }
 
+  get signer() {
+    return this._signer;
+  }
+
   /**
    * Issues credentials as identity.
    * Requires identity to be ready.

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

@@ -2,10 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Trigger } from '@dxos/async';
+import { Mutex, scheduleMicroTask, Trigger } from '@dxos/async';
 import { Context, Resource } from '@dxos/context';
 import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credentials';
-import { failUndefined } from '@dxos/debug';
+import { failUndefined, warnAfterTimeout } from '@dxos/debug';
 import {
   EchoEdgeReplicator,
   EchoHost,
@@ -14,7 +14,8 @@ import {
   SpaceManager,
   valueEncoding,
 } from '@dxos/echo-pipeline';
-import type { EdgeConnection } from '@dxos/edge-client';
+import { createChainEdgeIdentity, createEphemeralEdgeIdentity } from '@dxos/edge-client';
+import type { EdgeHttpClient, EdgeConnection } from '@dxos/edge-client';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
@@ -37,8 +38,8 @@ import { safeInstanceof } from '@dxos/util';
 import {
   IdentityManager,
   type CreateIdentityOptions,
-  type JoinIdentityParams,
   type IdentityManagerParams,
+  type JoinIdentityParams,
 } from '../identity';
 import {
   DeviceInvitationProtocol,
@@ -65,6 +66,8 @@ export type ServiceContextRuntimeParams = Pick<
 @safeInstanceof('dxos.client-services.ServiceContext')
 @Trace.resource()
 export class ServiceContext extends Resource {
+  private readonly _edgeIdentityUpdateMutex = new Mutex();
+
   public readonly initialized = new Trigger();
   public readonly metadataStore: MetadataStore;
   public readonly blobStore: BlobStore;
@@ -96,6 +99,7 @@ export class ServiceContext extends Resource {
     public readonly networkManager: SwarmNetworkManager,
     public readonly signalManager: SignalManager,
     private readonly _edgeConnection: EdgeConnection | undefined,
+    private readonly _edgeHttpClient: EdgeHttpClient | undefined,
     public readonly _runtimeParams?: ServiceContextRuntimeParams,
     private readonly _edgeFeatures?: Runtime.Client.EdgeFeatures,
   ) {
@@ -137,18 +141,33 @@ export class ServiceContext extends Resource {
       callbacks: {
         onIdentityConstruction: (identity) => {
           if (this._edgeConnection) {
-            log.info('Setting identity on edge connection', {
-              identity: identity.identityKey.toHex(),
-              oldIdentity: this._edgeConnection.identityKey,
-              swarms: this.networkManager.topics,
-            });
-            this._edgeConnection.setIdentity({
-              peerKey: identity.deviceKey.toHex(),
-              identityKey: identity.identityKey.toHex(),
-            });
-            this.networkManager.setPeerInfo({
-              identityKey: identity.identityKey.toHex(),
-              peerKey: identity.deviceKey.toHex(),
+            scheduleMicroTask(this._ctx, async () => {
+              using _ = await this._edgeIdentityUpdateMutex.acquire();
+
+              log.info('Setting identity on edge connection', {
+                identity: identity.identityKey.toHex(),
+                oldIdentity: this._edgeConnection!.identityKey,
+                swarms: this.networkManager.topics,
+              });
+
+              await warnAfterTimeout(10_000, 'Waiting for identity to be ready for edge connection', async () => {
+                await identity.ready();
+              });
+
+              invariant(identity.deviceCredentialChain);
+              this._edgeConnection!.setIdentity(
+                await createChainEdgeIdentity(
+                  identity.signer,
+                  identity.identityKey,
+                  identity.deviceKey,
+                  identity.deviceCredentialChain,
+                  [], // TODO(dmaretskyi): Service access credentials.
+                ),
+              );
+              this.networkManager.setPeerInfo({
+                identityKey: identity.identityKey.toHex(),
+                peerKey: identity.deviceKey.toHex(),
+              });
             });
           }
         },
@@ -197,7 +216,11 @@ export class ServiceContext extends Resource {
 
     log('opening...');
     log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
-    await this._edgeConnection?.open();
+    if (this._edgeConnection) {
+      // TODO(dmaretskyi): Use device key.
+      this._edgeConnection.setIdentity(await createEphemeralEdgeIdentity());
+      await this._edgeConnection.open();
+    }
     await this.signalManager.open();
     await this.networkManager.open();
 
@@ -304,6 +327,7 @@ export class ServiceContext extends Resource {
       echoHost: this.echoHost,
       invitationsManager: this.invitationsManager,
       edgeConnection: this._edgeConnection,
+      edgeHttpClient: this._edgeHttpClient,
       echoEdgeReplicator: this._echoEdgeReplicator,
       meshReplicator: this._meshReplicator,
       runtimeParams: this._runtimeParams as DataSpaceManagerRuntimeParams,

package/src/packlets/services/service-host.ts

@@ -6,7 +6,7 @@ import { Event, synchronized } from '@dxos/async';
 import { clientServiceBundle, type ClientServices } from '@dxos/client-protocol';
 import { type Config } from '@dxos/config';
 import { Context } from '@dxos/context';
-import { EdgeClient, type EdgeConnection } from '@dxos/edge-client';
+import { EdgeClient, EdgeHttpClient, createStubEdgeIdentity, type EdgeConnection } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
@@ -15,8 +15,8 @@ import { EdgeSignalManager, WebsocketSignalManager, type SignalManager } from '@
 import {
   SwarmNetworkManager,
   createIceProvider,
-  type TransportFactory,
   createRtcTransportFactory,
+  type TransportFactory,
 } from '@dxos/network-manager';
 import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
@@ -29,9 +29,9 @@ import { ServiceRegistry } from './service-registry';
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsHostEvents, DevtoolsServiceImpl } from '../devtools';
 import {
-  type CollectDiagnosticsBroadcastHandler,
   createCollectDiagnosticsBroadcastHandler,
   createDiagnostics,
+  type CollectDiagnosticsBroadcastHandler,
 } from '../diagnostics';
 import { IdentityServiceImpl, type CreateIdentityOptions } from '../identity';
 import { ContactsServiceImpl } from '../identity/contacts-service';
@@ -89,6 +89,7 @@ export class ClientServicesHost {
   private _callbacks?: ClientServicesHostCallbacks;
   private _devtoolsProxy?: WebsocketRpcClient<{}, ClientServices>;
   private _edgeConnection?: EdgeConnection = undefined;
+  private _edgeHttpClient?: EdgeHttpClient = undefined;
 
   private _serviceContext!: ServiceContext;
   private readonly _runtimeParams: ServiceContextRuntimeParams;
@@ -212,8 +213,8 @@ export class ClientServicesHost {
 
     const edgeEndpoint = config?.get('runtime.services.edge.url');
     if (edgeEndpoint) {
-      const randomKey = PublicKey.random().toHex();
-      this._edgeConnection = new EdgeClient(randomKey, randomKey, { socketEndpoint: edgeEndpoint });
+      this._edgeConnection = new EdgeClient(createStubEdgeIdentity(), { socketEndpoint: edgeEndpoint });
+      this._edgeHttpClient = new EdgeHttpClient(edgeEndpoint);
     }
 
     const {
@@ -278,6 +279,7 @@ export class ClientServicesHost {
       this._networkManager,
       this._signalManager,
       this._edgeConnection,
+      this._edgeHttpClient,
       this._runtimeParams,
       this._config.get('runtime.client.edgeFeatures'),
     );

package/src/packlets/spaces/data-space-manager.ts

@@ -36,7 +36,7 @@ import {
   type SpaceDoc,
 } from '@dxos/echo-protocol';
 import { TYPE_PROPERTIES, generateEchoId, getTypeReference } from '@dxos/echo-schema';
-import type { EdgeConnection } from '@dxos/edge-client';
+import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { writeMessages, type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -110,6 +110,7 @@ export type DataSpaceManagerParams = {
   echoHost: EchoHost;
   invitationsManager: InvitationsManager;
   edgeConnection?: EdgeConnection;
+  edgeHttpClient?: EdgeHttpClient;
   meshReplicator?: MeshEchoReplicator;
   echoEdgeReplicator?: EchoEdgeReplicator;
   runtimeParams?: DataSpaceManagerRuntimeParams;
@@ -138,6 +139,7 @@ export class DataSpaceManager extends Resource {
   private readonly _echoHost: EchoHost;
   private readonly _invitationsManager: InvitationsManager;
   private readonly _edgeConnection?: EdgeConnection = undefined;
+  private readonly _edgeHttpClient?: EdgeHttpClient = undefined;
   private readonly _edgeFeatures?: Runtime.Client.EdgeFeatures = undefined;
   private readonly _meshReplicator?: MeshEchoReplicator = undefined;
   private readonly _echoEdgeReplicator?: EchoEdgeReplicator = undefined;
@@ -157,6 +159,7 @@ export class DataSpaceManager extends Resource {
     this._edgeConnection = params.edgeConnection;
     this._edgeFeatures = params.edgeFeatures;
     this._echoEdgeReplicator = params.echoEdgeReplicator;
+    this._edgeHttpClient = params.edgeHttpClient;
     this._runtimeParams = params.runtimeParams;
 
     trace.diagnostic({
@@ -482,6 +485,7 @@ export class DataSpaceManager extends Resource {
       },
       cache: metadata.cache,
       edgeConnection: this._edgeConnection,
+      edgeHttpClient: this._edgeHttpClient,
       edgeFeatures: this._edgeFeatures,
     });
     dataSpace.postOpen.append(async () => {

package/src/packlets/spaces/data-space.ts

@@ -15,7 +15,7 @@ import {
   type Space,
 } from '@dxos/echo-pipeline';
 import { SpaceDocVersion } from '@dxos/echo-protocol';
-import type { EdgeConnection } from '@dxos/edge-client';
+import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { failedInvariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -80,6 +80,7 @@ export type DataSpaceParams = {
   callbacks?: DataSpaceCallbacks;
   cache?: SpaceCache;
   edgeConnection?: EdgeConnection;
+  edgeHttpClient?: EdgeHttpClient;
   edgeFeatures?: Runtime.Client.EdgeFeatures;
 };
 
@@ -101,7 +102,7 @@ export class DataSpace {
   private readonly _feedStore: FeedStore<FeedMessage>;
   private readonly _metadataStore: MetadataStore;
   private readonly _signingContext: SigningContext;
-  private readonly _notarizationPlugin = new NotarizationPlugin();
+  private readonly _notarizationPlugin: NotarizationPlugin;
   private readonly _callbacks: DataSpaceCallbacks;
   private readonly _cache?: SpaceCache = undefined;
   private readonly _echoHost: EchoHost;
@@ -141,6 +142,11 @@ export class DataSpace {
     this._signingContext = params.signingContext;
     this._callbacks = params.callbacks ?? {};
     this._echoHost = params.echoHost;
+    this._notarizationPlugin = new NotarizationPlugin({
+      spaceId: this._inner.id,
+      edgeClient: params.edgeHttpClient,
+      edgeFeatures: params.edgeFeatures,
+    });
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () =>
@@ -323,6 +329,7 @@ export class DataSpace {
     this._state = SpaceState.SPACE_INITIALIZING;
     log('new state', { state: SpaceState[this._state] });
 
+    log('initializing control pipeline');
     await this._initializeAndReadControlPipeline();
 
     // Allow other tasks to run before loading the data pipeline.
@@ -330,10 +337,13 @@ export class DataSpace {
 
     const ready = this.stateUpdate.waitForCondition(() => this._state === SpaceState.SPACE_READY);
 
+    log('initializing automerge root');
     this._automergeSpaceState.startProcessingRootDocs();
 
     // TODO(dmaretskyi): Change so `initializeDataPipeline` doesn't wait for the space to be READY, but rather any state with a valid root.
+    log('waiting for space to be ready');
     await ready;
+    log('space is ready');
   }
 
   private async _enterReadyState() {
@@ -350,6 +360,7 @@ export class DataSpace {
   private async _initializeAndReadControlPipeline() {
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
       ctx: this._ctx,
+      timeout: 10_000,
       breakOnStall: false,
     });
 
@@ -413,8 +424,16 @@ export class DataSpace {
     }
 
     if (credentials.length > 0) {
-      // Never times out
-      await this.notarizationPlugin.notarize({ ctx: this._ctx, credentials, timeout: 0 });
+      try {
+        log('will notarize credentials for feed admission', { count: credentials.length });
+        // Never times out
+        await this.notarizationPlugin.notarize({ ctx: this._ctx, credentials, timeout: 0 });
+
+        log('credentials notarized');
+      } catch (err) {
+        log.error('error notarizing credentials for feed admission', err);
+        throw err;
+      }
 
       // Set this after credentials are notarized so that on failure we will retry.
       await this._metadataStore.setWritableFeedKeys(this.key, this.inner.controlFeedKey!, this.inner.dataFeedKey!);

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -9,12 +9,12 @@ import { describe, test, onTestFinished, vi, expect } from 'vitest';
 import { Trigger, sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { valueEncoding } from '@dxos/echo-pipeline';
-import { EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
+import { createEphemeralEdgeIdentity, EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { type FeedWrapper } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
-import { PublicKey, SpaceId } from '@dxos/keys';
+import { SpaceId } from '@dxos/keys';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { createStorage } from '@dxos/random-access-storage';
 import { openAndClose } from '@dxos/test-utils';
@@ -41,6 +41,16 @@ describe('EdgeFeedReplicator', () => {
     expect(messageSink[0].type).toEqual('get-metadata');
   });
 
+  test('replicates if added to a connected client', async () => {
+    const { endpoint, admitConnection, messageSink } = await createEdge();
+    const { messenger } = await createClient(endpoint);
+    admitConnection.wake();
+    await expect.poll(() => messenger.isConnected).toBeTruthy();
+
+    await attachReplicator(messenger);
+    await expect.poll(() => messageSink.length).toEqual(1);
+  });
+
   test('sends a block', async () => {
     const { endpoint, admitConnection, messageSink } = await createEdge();
     const { messenger } = await createClient(endpoint);
@@ -63,7 +73,7 @@ describe('EdgeFeedReplicator', () => {
     admitConnection.wake();
     await expect.poll(() => messageSink.length).toEqual(1);
 
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
     await messenger.reconnect.waitForCount(1);
 
     await expect.poll(() => messageSink.length).toEqual(2);
@@ -83,7 +93,7 @@ describe('EdgeFeedReplicator', () => {
 
     await expect.poll(() => sendSpy.mock.calls.length).toEqual(1);
     expect(messageSink.length).toEqual(0);
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
 
     await expect.poll(() => messageSink.length).toEqual(1);
     expect(messageSink[0].type).toEqual('get-metadata');
@@ -107,10 +117,9 @@ describe('EdgeFeedReplicator', () => {
 
     await expect.poll(() => sendSpy.mock.calls.length).toEqual(2);
     expect(messageSink.length).toEqual(0);
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
 
-    await expect.poll(() => messageSink.length).toEqual(2);
-    expect(messageSink[1].type).toEqual('data');
+    await expect.poll(() => messageSink.find((msg) => msg.type === 'data')).toBeDefined();
   });
 
   test('propagates errors unrelated to reconnect', async () => {
@@ -137,7 +146,7 @@ describe('EdgeFeedReplicator', () => {
     const { messenger } = await createClient(endpoint);
 
     await attachReplicator(messenger);
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
     await sleep(100);
     admitConnection.wake();
 
@@ -154,7 +163,7 @@ describe('EdgeFeedReplicator', () => {
     await sleep(10);
 
     admitConnection.reset();
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
     await appendMessage(feed);
     await sleep(20);
     admitConnection.wake();
@@ -171,7 +180,7 @@ describe('EdgeFeedReplicator', () => {
     await sleep(10);
 
     void appendMessage(feed);
-    updateIdentity(messenger);
+    await updateIdentity(messenger);
 
     await expect.poll(() => feedLength()).toEqual(1);
   });
@@ -203,8 +212,7 @@ describe('EdgeFeedReplicator', () => {
   };
 
   const createClient = async (endpoint: string) => {
-    const peerKey = PublicKey.random().toHex();
-    const messenger = new EdgeClient(peerKey, peerKey, { socketEndpoint: endpoint });
+    const messenger = new EdgeClient(await createEphemeralEdgeIdentity(), { socketEndpoint: endpoint });
     const sendSpy = vi.spyOn(messenger, 'send');
     await openAndClose(messenger);
     return { messenger, sendSpy };
@@ -235,9 +243,8 @@ describe('EdgeFeedReplicator', () => {
     return feedStore.openFeed(await keyring.createKey(), { writable: true });
   };
 
-  const updateIdentity = (messenger: EdgeClient) => {
-    const identityKey = PublicKey.random().toHex();
-    messenger.setIdentity({ peerKey: messenger.peerKey, identityKey });
+  const updateIdentity = async (messenger: EdgeClient) => {
+    messenger.setIdentity(await createEphemeralEdgeIdentity());
   };
 
   const appendMessage = (feed: FeedWrapper<FeedMessage>) => feed.append({ timeframe: new Timeframe() });

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -11,7 +11,7 @@ import { EdgeConnectionClosedError, EdgeIdentityChangedError } from '@dxos/edge-
 import { type FeedWrapper } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { PublicKey, type SpaceId } from '@dxos/keys';
-import { log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { EdgeService } from '@dxos/protocols';
 import { buf } from '@dxos/protocols/buf';
 import {
@@ -28,7 +28,10 @@ export type EdgeFeedReplicatorParams = {
 
 export class EdgeFeedReplicator extends Resource {
   private readonly _messenger: EdgeConnection;
+
+  @logInfo
   private readonly _spaceId: SpaceId;
+
   private readonly _feeds = new ComplexMap<PublicKey, FeedWrapper<any>>(PublicKey.hash);
 
   private _connectionCtx?: Context = undefined;
@@ -50,6 +53,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   protected override async _open(): Promise<void> {
+    log('open');
     // TODO: handle reconnects
     this._ctx.onDispose(
       this._messenger.addListener((message: RouterMessage) => {
@@ -68,43 +72,40 @@ export class EdgeFeedReplicator extends Resource {
         }
 
         const payload = decodeCbor(message.payload!.value) as ProtocolMessage;
-        log.info('receive', { from: message.source, feedKey: payload.feedKey, type: payload.type });
+        log('receive', { from: message.source, feedKey: payload.feedKey, type: payload.type });
         this._onMessage(payload);
       }),
     );
 
     this._messenger.connected.on(this._ctx, async () => {
       await this._resetConnection();
-
-      this._connected = true;
-      const connectionCtx = new Context({
-        onError: async (err: any) => {
-          if (connectionCtx !== this._connectionCtx) {
-            return;
-          }
-          if (err instanceof EdgeIdentityChangedError || err instanceof EdgeConnectionClosedError) {
-            log('resetting on reconnect');
-            await this._resetConnection();
-          } else {
-            this._ctx.raise(err);
-          }
-        },
-      });
-      this._connectionCtx = connectionCtx;
-      log('connection context created');
-      scheduleMicroTask(connectionCtx, async () => {
-        for (const feed of this._feeds.values()) {
-          await this._replicateFeed(connectionCtx, feed);
-        }
-      });
+      this._startReplication();
     });
+
+    if (this._messenger.isConnected) {
+      this._startReplication();
+    }
   }
 
   protected override async _close(): Promise<void> {
+    log('close');
     await this._resetConnection();
   }
 
+  private _startReplication() {
+    this._connected = true;
+    const connectionCtx = this._createConnectionContext();
+    this._connectionCtx = connectionCtx;
+    log('connection context created');
+    scheduleMicroTask(connectionCtx, async () => {
+      for (const feed of this._feeds.values()) {
+        await this._replicateFeed(connectionCtx, feed);
+      }
+    });
+  }
+
   private async _resetConnection() {
+    log('resetConnection');
     this._connected = false;
     await this._connectionCtx?.dispose();
     this._connectionCtx = undefined;
@@ -112,7 +113,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   async addFeed(feed: FeedWrapper<any>) {
-    log.info('addFeed', { key: feed.key });
+    log.info('addFeed', { key: feed.key, connected: this._connected, hasConnectionCtx: !!this._connectionCtx });
     this._feeds.set(feed.key, feed);
 
     if (this._connected && this._connectionCtx) {
@@ -125,6 +126,7 @@ export class EdgeFeedReplicator extends Resource {
   }
 
   private async _replicateFeed(ctx: Context, feed: FeedWrapper<any>) {
+    log('replicateFeed', { key: feed.key });
     await this._sendMessage({
       type: 'get-metadata',
       feedKey: feed.key.toHex(),
@@ -148,6 +150,7 @@ export class EdgeFeedReplicator extends Resource {
     invariant(message.feedKey);
     const payloadValue = bufferToArray(encodeCbor(message));
 
+    log('send', { type: message.type });
     await this._messenger.send(
       buf.create(RouterMessageSchema, {
         source: {
@@ -272,6 +275,23 @@ export class EdgeFeedReplicator extends Resource {
       await this._pushBlocks(feed, remoteLength, feed.length);
     }
   }
+
+  private _createConnectionContext() {
+    const connectionCtx = new Context({
+      onError: async (err: any) => {
+        if (connectionCtx !== this._connectionCtx) {
+          return;
+        }
+        if (err instanceof EdgeIdentityChangedError || err instanceof EdgeConnectionClosedError) {
+          log('resetting on reconnect');
+          await this._resetConnection();
+        } else {
+          this._ctx.raise(err);
+        }
+      },
+    });
+    return connectionCtx;
+  }
 }
 
 // hypercore requires buffers

package/src/packlets/spaces/notarization-plugin.test.ts

@@ -8,20 +8,22 @@ import { Context } from '@dxos/context';
 import { CredentialGenerator } from '@dxos/credentials';
 import { MockFeedWriter } from '@dxos/feed-store/testing';
 import { Keyring } from '@dxos/keyring';
+import { SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { AdmittedFeed, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { TestBuilder, type TestConnection, TestPeer } from '@dxos/teleport/testing';
 
-import { NotarizationPlugin } from './notarization-plugin';
+import { NotarizationPlugin, type NotarizationPluginParams } from './notarization-plugin';
 
 class TestAgent extends TestPeer {
   private readonly _ctx = new Context();
 
   feed = new MockFeedWriter<Credential>();
-  notarizationPlugin = new NotarizationPlugin();
+  notarizationPlugin: NotarizationPlugin;
 
-  constructor() {
+  constructor(params: NotarizationPluginParams) {
     super();
+    this.notarizationPlugin = new NotarizationPlugin(params);
     this.feed.written.on(this._ctx, async ([credential]) => {
       log('written to feed', { credential });
       await this.notarizationPlugin.processCredential(credential);
@@ -50,8 +52,10 @@ describe('NotarizationPlugin', () => {
     const testBuilder = new TestBuilder();
     onTestFinished(() => testBuilder.destroy());
 
+    const params = { spaceId: SpaceId.random() };
+
     // peer0 is there to test retries.
-    const [_peer0, peer1, peer2] = await testBuilder.createPeers({ factory: () => new TestAgent() });
+    const [_peer0, peer1, peer2] = await testBuilder.createPeers({ factory: () => new TestAgent(params) });
     peer1.enableWriting();
 
     peer1.feed.written.on(async ([credential]) => {