@dxos/client-services 0.6.11 → 0.6.12-main.568932b

package/src/packlets/identity/{authenticator.test.ts → authenticator.node.test.ts}

@@ -2,14 +2,13 @@
 // Copyright 2022 DXOS.org
 //
 
-import expect from 'expect';
+import { describe, expect, test } from 'vitest';
 
 import { Event } from '@dxos/async';
 import { createCredentialSignerWithKey } from '@dxos/credentials';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
-import { describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
 import { createAuthProvider, TrustedKeySetAuthVerifier } from './authenticator';
@@ -30,5 +29,5 @@ describe('identity/authenticator', () => {
     const credential = await authProvider(nonce);
     invariant(credential);
     expect(await authVerifier.verifier(nonce, credential)).toBeTruthy();
-  }).onlyEnvironments('nodejs');
+  });
 });

package/src/packlets/identity/authenticator.ts

@@ -67,7 +67,7 @@ export class TrustedKeySetAuthVerifier {
       }
 
       if (this._isTrustedKey(credential.issuer)) {
-        log('key is not currently in trusted set, waiting...', { key: credential.issuer });
+        log('key is trusted -- auth success', { key: credential.issuer });
         return true;
       }
 
@@ -81,7 +81,10 @@ export class TrustedKeySetAuthVerifier {
           log('auth success', { key: credential.issuer });
           trigger.wake(true);
         } else {
-          log('key is not currently in trusted set, waiting...', { key: credential.issuer });
+          log('key is not currently in trusted set, waiting...', {
+            key: credential.issuer,
+            trusted: [...this._params.trustedKeysProvider()],
+          });
         }
       });
 

package/src/packlets/identity/contacts-service.ts

@@ -5,7 +5,7 @@
 import { EventSubscriptions, scheduleTask, UpdateScheduler } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { type MemberInfo } from '@dxos/credentials';
-import type { SpaceManager } from '@dxos/echo-pipeline';
+import { type SpaceManager } from '@dxos/echo-pipeline';
 import { PublicKey } from '@dxos/keys';
 import { type Contact, type ContactBook, type ContactsService } from '@dxos/protocols/proto/dxos/client/services';
 import { ComplexMap, ComplexSet } from '@dxos/util';

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

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { expect } from 'chai';
+import { describe, expect, test, onTestFinished } from 'vitest';
 
 import { Context } from '@dxos/context';
 import { valueEncoding, MetadataStore, SpaceManager, AuthStatus } from '@dxos/echo-pipeline';
@@ -13,7 +13,6 @@ import { MemoryTransportFactory, SwarmNetworkManager } from '@dxos/network-manag
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { createStorage, type Storage, StorageType } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
-import { describe, test, afterTest } from '@dxos/test';
 
 import { IdentityManager } from './identity-manager';
 
@@ -39,7 +38,7 @@ describe('identity/identity-manager', () => {
       }),
     });
 
-    afterTest(() => feedStore.close());
+    onTestFinished(() => feedStore.close());
 
     const networkManager = new SwarmNetworkManager({
       signalManager: new MemorySignalManager(signalContext),
@@ -51,7 +50,7 @@ describe('identity/identity-manager', () => {
       blobStore,
       metadataStore,
     });
-    const identityManager = new IdentityManager(metadataStore, keyring, feedStore, spaceManager);
+    const identityManager = new IdentityManager({ metadataStore, keyring, feedStore, spaceManager });
 
     return {
       metadataStore,
@@ -64,7 +63,7 @@ describe('identity/identity-manager', () => {
   test('creates identity', async () => {
     const { identityManager } = await setupPeer();
     await identityManager.open(new Context());
-    afterTest(() => identityManager.close());
+    onTestFinished(() => identityManager.close());
 
     const identity = await identityManager.createIdentity();
     expect(identity).to.exist;
@@ -95,7 +94,7 @@ describe('identity/identity-manager', () => {
   test('update profile', async () => {
     const { identityManager } = await setupPeer();
     await identityManager.open(new Context());
-    afterTest(() => identityManager.close());
+    onTestFinished(() => identityManager.close());
 
     const identity = await identityManager.createIdentity();
     expect(identity.profileDocument?.displayName).to.be.undefined;

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

@@ -7,6 +7,7 @@ import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createCredentialSignerWithKey, CredentialGenerator } from '@dxos/credentials';
 import { type MetadataStore, type SpaceManager, type SwarmIdentity } from '@dxos/echo-pipeline';
+import { type EdgeConnection } from '@dxos/edge-client';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -14,6 +15,7 @@ import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { trace } from '@dxos/protocols';
 import { Device, DeviceKind } from '@dxos/protocols/proto/dxos/client/services';
+import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type IdentityRecord, type SpaceMetadata } from '@dxos/protocols/proto/dxos/echo/metadata';
 import {
@@ -63,9 +65,20 @@ export type CreateIdentityOptions = {
   deviceProfile?: DeviceProfileDocument;
 };
 
-export type IdentityManagerRuntimeParams = {
+export type IdentityManagerCallbacks = {
+  onIdentityConstruction?: (identity: Identity) => void;
+};
+
+export type IdentityManagerParams = {
+  metadataStore: MetadataStore;
+  keyring: Keyring;
+  feedStore: FeedStore<FeedMessage>;
+  spaceManager: SpaceManager;
+  edgeConnection?: EdgeConnection;
+  edgeFeatures?: Runtime.Client.EdgeFeatures;
   devicePresenceAnnounceInterval?: number;
   devicePresenceOfflineTimeout?: number;
+  callbacks?: IdentityManagerCallbacks;
 };
 
 // TODO(dmaretskyi): Rename: represents the peer's state machine.
@@ -73,28 +86,29 @@ export type IdentityManagerRuntimeParams = {
 export class IdentityManager {
   readonly stateUpdate = new Event();
 
-  private _identity?: Identity;
+  private readonly _metadataStore: MetadataStore;
+  private readonly _keyring: Keyring;
+  private readonly _feedStore: FeedStore<FeedMessage>;
+  private readonly _spaceManager: SpaceManager;
   private readonly _devicePresenceAnnounceInterval: number;
   private readonly _devicePresenceOfflineTimeout: number;
+  private readonly _edgeConnection: EdgeConnection | undefined;
+  private readonly _edgeFeatures: Runtime.Client.EdgeFeatures | undefined;
+  private readonly _callbacks: IdentityManagerCallbacks | undefined;
+
+  private _identity?: Identity;
 
-  // TODO(burdon): IdentityManagerParams.
   // TODO(dmaretskyi): Perhaps this should take/generate the peerKey outside of an initialized identity.
-  constructor(
-    private readonly _metadataStore: MetadataStore,
-    private readonly _keyring: Keyring,
-    private readonly _feedStore: FeedStore<FeedMessage>,
-    private readonly _spaceManager: SpaceManager,
-    params?: IdentityManagerRuntimeParams,
-    private readonly _callbacks?: {
-      onIdentityConstruction?: (identity: Identity) => void;
-    },
-  ) {
-    const {
-      devicePresenceAnnounceInterval = DEVICE_PRESENCE_ANNOUNCE_INTERVAL,
-      devicePresenceOfflineTimeout = DEVICE_PRESENCE_OFFLINE_TIMEOUT,
-    } = params ?? {};
-    this._devicePresenceAnnounceInterval = devicePresenceAnnounceInterval;
-    this._devicePresenceOfflineTimeout = devicePresenceOfflineTimeout;
+  constructor(params: IdentityManagerParams) {
+    this._metadataStore = params.metadataStore;
+    this._keyring = params.keyring;
+    this._feedStore = params.feedStore;
+    this._spaceManager = params.spaceManager;
+    this._edgeConnection = params.edgeConnection;
+    this._edgeFeatures = params.edgeFeatures;
+    this._devicePresenceAnnounceInterval = params.devicePresenceAnnounceInterval ?? DEVICE_PRESENCE_ANNOUNCE_INTERVAL;
+    this._devicePresenceOfflineTimeout = params.devicePresenceOfflineTimeout ?? DEVICE_PRESENCE_OFFLINE_TIMEOUT;
+    this._callbacks = params.callbacks;
   }
 
   get identity() {
@@ -360,6 +374,8 @@ export class IdentityManager {
       signer: this._keyring,
       identityKey: identityRecord.identityKey,
       deviceKey: identityRecord.deviceKey,
+      edgeConnection: this._edgeConnection,
+      edgeFeatures: this._edgeFeatures,
     });
     log('done', { identityKey: identityRecord.identityKey });
     this._callbacks?.onIdentityConstruction?.(identity);

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

@@ -2,21 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type Identity, type IdentityService } from '@dxos/protocols/proto/dxos/client/services';
-import { afterEach, afterTest, beforeEach, describe, test } from '@dxos/test';
 
 import { IdentityServiceImpl } from './identity-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
 
-chai.use(chaiAsPromised);
-
 describe('IdentityService', () => {
   let serviceContext: ServiceContext;
   let identityService: IdentityService;
@@ -49,7 +45,7 @@ describe('IdentityService', () => {
 
     test('fails to create identity if one already exists', async () => {
       await identityService.createIdentity({});
-      await expect(identityService.createIdentity({})).to.be.rejectedWith('Identity already exists');
+      await expect(identityService.createIdentity({})).rejects.toThrowError('Identity already exists');
     });
   });
 
@@ -72,7 +68,7 @@ describe('IdentityService', () => {
       query.subscribe(({ identity }) => {
         result.wake(identity);
       });
-      afterTest(() => query.close());
+      onTestFinished(() => query.close());
       expect(await result.wait()).to.be.undefined;
     });
 
@@ -82,7 +78,7 @@ describe('IdentityService', () => {
       query.subscribe(({ identity }) => {
         result.wake(identity);
       });
-      afterTest(() => query.close());
+      onTestFinished(() => query.close());
       expect(await result.wait()).to.be.undefined;
 
       result = new Trigger<Identity | undefined>();

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>;
+};