@dxos/client-services 0.6.12-main.5cc132e → 0.6.12-main.78ddbdf

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/client-services",
-  "version": "0.6.12-main.5cc132e",
+  "version": "0.6.12-main.78ddbdf",
   "description": "DXOS client services implementation",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -47,47 +47,48 @@
   "dependencies": {
     "cbor-x": "^1.5.4",
     "platform": "^1.3.6",
-    "@dxos/async": "0.6.12-main.5cc132e",
-    "@dxos/automerge": "0.6.12-main.5cc132e",
-    "@dxos/client-protocol": "0.6.12-main.5cc132e",
-    "@dxos/config": "0.6.12-main.5cc132e",
-    "@dxos/codec-protobuf": "0.6.12-main.5cc132e",
-    "@dxos/context": "0.6.12-main.5cc132e",
-    "@dxos/crypto": "0.6.12-main.5cc132e",
-    "@dxos/credentials": "0.6.12-main.5cc132e",
-    "@dxos/debug": "0.6.12-main.5cc132e",
-    "@dxos/echo-db": "0.6.12-main.5cc132e",
-    "@dxos/echo-schema": "0.6.12-main.5cc132e",
-    "@dxos/echo-pipeline": "0.6.12-main.5cc132e",
-    "@dxos/edge-client": "0.6.12-main.5cc132e",
-    "@dxos/echo-protocol": "0.6.12-main.5cc132e",
-    "@dxos/feed-store": "0.6.12-main.5cc132e",
-    "@dxos/indexing": "0.6.12-main.5cc132e",
-    "@dxos/keyring": "0.6.12-main.5cc132e",
-    "@dxos/keys": "0.6.12-main.5cc132e",
-    "@dxos/lock-file": "0.6.12-main.5cc132e",
-    "@dxos/invariant": "0.6.12-main.5cc132e",
-    "@dxos/kv-store": "0.6.12-main.5cc132e",
-    "@dxos/log": "0.6.12-main.5cc132e",
-    "@dxos/messaging": "0.6.12-main.5cc132e",
-    "@dxos/node-std": "0.6.12-main.5cc132e",
-    "@dxos/network-manager": "0.6.12-main.5cc132e",
-    "@dxos/protocols": "0.6.12-main.5cc132e",
-    "@dxos/random-access-storage": "0.6.12-main.5cc132e",
-    "@dxos/teleport": "0.6.12-main.5cc132e",
-    "@dxos/rpc": "0.6.12-main.5cc132e",
-    "@dxos/teleport-extension-gossip": "0.6.12-main.5cc132e",
-    "@dxos/teleport-extension-object-sync": "0.6.12-main.5cc132e",
-    "@dxos/timeframe": "0.6.12-main.5cc132e",
-    "@dxos/tracing": "0.6.12-main.5cc132e",
-    "@dxos/util": "0.6.12-main.5cc132e",
-    "@dxos/websocket-rpc": "0.6.12-main.5cc132e"
+    "@dxos/async": "0.6.12-main.78ddbdf",
+    "@dxos/client-protocol": "0.6.12-main.78ddbdf",
+    "@dxos/config": "0.6.12-main.78ddbdf",
+    "@dxos/codec-protobuf": "0.6.12-main.78ddbdf",
+    "@dxos/automerge": "0.6.12-main.78ddbdf",
+    "@dxos/context": "0.6.12-main.78ddbdf",
+    "@dxos/crypto": "0.6.12-main.78ddbdf",
+    "@dxos/credentials": "0.6.12-main.78ddbdf",
+    "@dxos/debug": "0.6.12-main.78ddbdf",
+    "@dxos/echo-db": "0.6.12-main.78ddbdf",
+    "@dxos/echo-pipeline": "0.6.12-main.78ddbdf",
+    "@dxos/echo-protocol": "0.6.12-main.78ddbdf",
+    "@dxos/echo-schema": "0.6.12-main.78ddbdf",
+    "@dxos/feed-store": "0.6.12-main.78ddbdf",
+    "@dxos/indexing": "0.6.12-main.78ddbdf",
+    "@dxos/edge-client": "0.6.12-main.78ddbdf",
+    "@dxos/invariant": "0.6.12-main.78ddbdf",
+    "@dxos/keyring": "0.6.12-main.78ddbdf",
+    "@dxos/keys": "0.6.12-main.78ddbdf",
+    "@dxos/lock-file": "0.6.12-main.78ddbdf",
+    "@dxos/log": "0.6.12-main.78ddbdf",
+    "@dxos/kv-store": "0.6.12-main.78ddbdf",
+    "@dxos/messaging": "0.6.12-main.78ddbdf",
+    "@dxos/network-manager": "0.6.12-main.78ddbdf",
+    "@dxos/node-std": "0.6.12-main.78ddbdf",
+    "@dxos/random-access-storage": "0.6.12-main.78ddbdf",
+    "@dxos/protocols": "0.6.12-main.78ddbdf",
+    "@dxos/teleport": "0.6.12-main.78ddbdf",
+    "@dxos/rpc": "0.6.12-main.78ddbdf",
+    "@dxos/teleport-extension-gossip": "0.6.12-main.78ddbdf",
+    "@dxos/timeframe": "0.6.12-main.78ddbdf",
+    "@dxos/tracing": "0.6.12-main.78ddbdf",
+    "@dxos/teleport-extension-object-sync": "0.6.12-main.78ddbdf",
+    "@dxos/util": "0.6.12-main.78ddbdf",
+    "@dxos/websocket-rpc": "0.6.12-main.78ddbdf"
   },
   "devDependencies": {
     "@types/platform": "^1.3.4",
     "@types/readable-stream": "^2.3.9",
-    "@dxos/signal": "0.6.12-main.5cc132e",
-    "@dxos/test-utils": "0.6.12-main.5cc132e"
+    "get-port-please": "^3.1.1",
+    "@dxos/signal": "0.6.12-main.78ddbdf",
+    "@dxos/test-utils": "0.6.12-main.78ddbdf"
   },
   "publishConfig": {
     "access": "public"

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

@@ -50,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,

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.test.ts

@@ -4,6 +4,7 @@
 
 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';
@@ -41,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,
@@ -76,7 +171,7 @@ describe('identity/identity', () => {
       },
       blobStore,
       networkManager: new SwarmNetworkManager({
-        signalManager: new MemorySignalManager(new MemorySignalManagerContext()),
+        signalManager: new MemorySignalManager(args?.signalContext ?? new MemorySignalManagerContext()),
         transportFactory: MemoryTransportFactory,
       }),
     });
@@ -86,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,
@@ -102,242 +197,37 @@ 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 };
+  };
 
-    //
-    // 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());
-      onTestFinished(() => 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,
-        }),
-      });
-
-      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());
-      onTestFinished(() => 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>;
+};