@dxos/client-services 0.8.4-main.c85a9c8dae → 0.8.4-main.d05539e30a

package/src/packlets/services/client-rpc-server.ts

@@ -3,7 +3,7 @@
 //
 
 import { type ClientServices } from '@dxos/client-protocol';
-import { type Any, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
+import { type Any, type RequestOptions, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
 import { RpcPeer, type RpcPeerOptions, type ServiceBundle, parseMethodName } from '@dxos/rpc';
 import { MapCounter, trace } from '@dxos/tracing';
@@ -16,12 +16,14 @@ export type ClientRpcServerProps = {
   handleCall?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => MaybePromise<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => MaybePromise<Any>,
+    options?: RequestOptions,
   ) => Promise<Any>;
   handleStream?: (
     method: string,
     params: Any,
-    handler: (method: string, params: Any) => Stream<Any>,
+    handler: (method: string, params: Any, options?: RequestOptions) => Stream<Any>,
+    options?: RequestOptions,
   ) => MaybePromise<Stream<Any>>;
 } & Omit<RpcPeerOptions, 'callHandler' | 'streamHandler'>;
 
@@ -49,32 +51,33 @@ export class ClientRpcServer {
     this._serviceRegistry = serviceRegistry;
     this._rpcPeer = new RpcPeer({
       ...rpcOptions,
-      callHandler: (method, params) => {
+      callHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) => this._getServiceHandler(serviceName).call(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).call(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request`);
 
         if (this._handleCall) {
-          return this._handleCall(methodName, params, handler);
+          return this._handleCall(methodName, params, handler, options);
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
-      streamHandler: (method, params) => {
+      streamHandler: (method, params, options) => {
         const [serviceName, methodName] = parseMethodName(method);
-        const handler = (method: string, params: Any) =>
-          this._getServiceHandler(serviceName).callStream(method, params);
+        const handler = (method: string, params: Any, handlerOptions?: RequestOptions) =>
+          this._getServiceHandler(serviceName).callStream(method, params, handlerOptions);
 
         this._callMetrics.inc(`${serviceName}.${methodName} request stream`);
 
         if (this._handleStream) {
-          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler)), (data) => {
+          return Stream.map(Stream.unwrapPromise(this._handleStream(methodName, params, handler, options)), (data) => {
             this._callMetrics.inc(`${serviceName}.${methodName} response stream`);
             return data;
           });
         } else {
-          return handler(methodName, params);
+          return handler(methodName, params, options);
         }
       },
     });

package/src/packlets/services/feed-syncer.test.ts

@@ -69,9 +69,9 @@ const createEdgeConnection = ({
     setIdentity: () => {},
     open: async () => {},
     close: async () => {},
-    send: async (routerMessage: RouterMessage) => {
+    send: async (ctx, routerMessage: RouterMessage) => {
       const decoded = cborDecode(routerMessage.payload!.value) as ProtocolMessage;
-      await syncServer.handleMessage(decoded).pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+      await syncServer.handleMessage(ctx, decoded).pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
     },
     onMessage: (listener: (message: RouterMessage) => void) => {
       messageListeners.add(listener);
@@ -105,7 +105,7 @@ const createFeedSyncHarness = async ({
   const syncServer = new SyncServer({
     peerId: 'server',
     feedStore: serverFeedStore,
-    sendMessage: (message) =>
+    sendMessage: (_ctx, message) =>
       Effect.promise(async () => {
         const routerMessage = createBuf(MessageSchema, {
           source: {

package/src/packlets/services/feed-syncer.ts

@@ -8,12 +8,13 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { AsyncTask, scheduleTask } from '@dxos/async';
-import { Resource } from '@dxos/context';
+import { Context, Resource } from '@dxos/context';
 import { type EdgeConnection, MessageSchema } from '@dxos/edge-client';
 import { RuntimeProvider } from '@dxos/effect';
 import { type FeedStore, SyncClient } from '@dxos/feed';
 import { invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { FeedProtocol } from '@dxos/protocols';
 import { EdgeService } from '@dxos/protocols';
 import { createBuf } from '@dxos/protocols/buf';
@@ -113,6 +114,10 @@ export class FeedSyncer extends Resource {
         if (service !== EdgeService.QUEUE_REPLICATOR) {
           return;
         }
+        log('feed sync edge ingress', {
+          serviceId: msg.serviceId,
+          payloadByteLength: msg.payload?.value?.byteLength,
+        });
         const handleMessageEffect = Effect.gen(this, function* () {
           const decoded = yield* Effect.try({
             try: () => cborXdecode(msg.payload!.value),
@@ -120,7 +125,17 @@ export class FeedSyncer extends Resource {
           });
           const payload = yield* Schema.validate(FeedProtocol.ProtocolMessage)(decoded);
           yield* this.#syncClient.handleMessage(payload);
-        });
+        }).pipe(
+          Effect.tapError((cause) =>
+            Effect.sync(() =>
+              log('feed sync edge message handling failed', {
+                serviceId: msg.serviceId,
+                payloadByteLength: msg.payload?.value?.byteLength,
+                cause: cause instanceof Error ? cause.message : String(cause),
+              }),
+            ),
+          ),
+        );
 
         void RuntimeProvider.runPromise(this.#runtime)(handleMessageEffect);
       }),
@@ -128,7 +143,12 @@ export class FeedSyncer extends Resource {
 
     this._ctx.onDispose(
       // NOTE: This will fire immediately if the connection is already open.
-      this.#edgeClient.onReconnected(async () => {}),
+      this.#edgeClient.onReconnected(async () => {
+        log('feed sync edge reconnected', {
+          peerKey: this.#edgeClient.peerKey,
+          identityKey: this.#edgeClient.identityKey,
+        });
+      }),
     );
 
     this.#feedStore.onNewBlocks.on(this._ctx, () => {
@@ -176,17 +196,20 @@ export class FeedSyncer extends Resource {
   /**
    * Performs queue sync and blocks until there are no pending sync batches.
    */
-  async syncBlocking({
-    spaceId,
-    subspaceTag,
-    shouldPush = true,
-    shouldPull = true,
-  }: {
-    spaceId: SpaceId;
-    subspaceTag: string;
-    shouldPush?: boolean;
-    shouldPull?: boolean;
-  }): Promise<void> {
+  async syncBlocking(
+    ctx: Context,
+    {
+      spaceId,
+      subspaceTag,
+      shouldPush = true,
+      shouldPull = true,
+    }: {
+      spaceId: SpaceId;
+      subspaceTag: string;
+      shouldPush?: boolean;
+      shouldPull?: boolean;
+    },
+  ): Promise<void> {
     invariant(SpaceId.isValid(spaceId));
     invariant(FeedProtocol.isWellKnownNamespace(subspaceTag));
     if (!shouldPush && !shouldPull) {
@@ -200,7 +223,7 @@ export class FeedSyncer extends Resource {
         while (!done) {
           done = true;
           if (shouldPull) {
-            const pullResult = yield* this.#syncClient.pull({
+            const pullResult = yield* this.#syncClient.pull(ctx, {
               spaceId,
               feedNamespace: subspaceTag,
               limit: this.#messageBlocksLimit,
@@ -209,7 +232,7 @@ export class FeedSyncer extends Resource {
           }
 
           if (shouldPush) {
-            const pushResult = yield* this.#syncClient.push({
+            const pushResult = yield* this.#syncClient.push(ctx, {
               spaceId,
               feedNamespace: subspaceTag,
               limit: this.#messageBlocksLimit,
@@ -233,20 +256,44 @@ export class FeedSyncer extends Resource {
     this.#lastFullPoll = Date.now();
   }
 
-  #sendMessage(message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest): Effect.Effect<void, unknown, never> {
+  #sendMessage(
+    ctx: Context,
+    message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest,
+  ): Effect.Effect<void, unknown, never> {
     return Effect.gen(this, function* () {
       const encoded = encoder.encode(message);
+      const serviceId = this.#getTargetServiceId(message);
+      const rpcTag = 'blocks' in message ? 'AppendRequest' : 'QueryRequest';
+      log('feed sync edge rpc outgoing', {
+        tag: rpcTag,
+        serviceId,
+        payloadByteLength: encoded.byteLength,
+        spaceId: message.spaceId,
+        feedNamespace: message.feedNamespace,
+        requestId: message.requestId,
+      });
       yield* Effect.tryPromise(async () =>
         this.#edgeClient.send(
+          ctx,
           createBuf(MessageSchema, {
             source: {
               identityKey: this.#edgeClient.identityKey,
               peerKey: this.#edgeClient.peerKey,
             },
-            serviceId: this.#getTargetServiceId(message),
+            serviceId,
             payload: { value: bufferToArray(encoded) },
           }),
         ),
+      ).pipe(
+        Effect.tapError((cause) =>
+          Effect.sync(() =>
+            log('feed sync edge send failed', {
+              serviceId,
+              tag: rpcTag,
+              cause: cause instanceof Error ? cause.message : String(cause),
+            }),
+          ),
+        ),
       );
     });
   }
@@ -266,7 +313,7 @@ export class FeedSyncer extends Resource {
           Effect.gen(this, function* () {
             let doneForAllNamespaces = true;
             for (const feedNamespace of this.#syncNamespaces) {
-              const { done } = yield* this.#syncClient.pull({
+              const { done } = yield* this.#syncClient.pull(this._ctx, {
                 spaceId,
                 feedNamespace,
                 limit: this.#messageBlocksLimit,
@@ -309,7 +356,7 @@ export class FeedSyncer extends Resource {
           Effect.gen(this, function* () {
             let doneForAllNamespaces = true;
             for (const feedNamespace of this.#syncNamespaces) {
-              const { done } = yield* this.#syncClient.push({
+              const { done } = yield* this.#syncClient.push(this._ctx, {
                 spaceId,
                 feedNamespace,
                 limit: this.#messageBlocksLimit,

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

@@ -4,6 +4,7 @@
 
 import { describe, test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { openAndClose } from '@dxos/test-utils';
@@ -19,7 +20,7 @@ describe('services/ServiceContext', () => {
     const device2 = await createOpenServiceContext(networkContext);
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
-    const space1 = await device1.dataSpaceManager!.createSpace();
+    const space1 = await device1.dataSpaceManager!.createSpace(new Context());
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
     await space2!.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
@@ -35,7 +36,7 @@ describe('services/ServiceContext', () => {
 
     const identity2 = await createOpenServiceContext(networkContext);
     await identity2.createIdentity();
-    const space1 = await identity2.dataSpaceManager!.createSpace();
+    const space1 = await identity2.dataSpaceManager!.createSpace(new Context());
     await Promise.all(
       performInvitation({
         host: identity2,

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

@@ -10,7 +10,9 @@ import { type CredentialProcessor, getCredentialAssertion } from '@dxos/credenti
 import { failUndefined, warnAfterTimeout } from '@dxos/debug';
 import {
   EchoEdgeReplicator,
+  EchoEdgeSubductionReplicator,
   EchoHost,
+  type EdgeAutomergeReplicator,
   MeshEchoReplicator,
   MetadataStore,
   SpaceManager,
@@ -22,12 +24,12 @@ import { type RuntimeProvider } from '@dxos/effect';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { Keyring } from '@dxos/keyring';
-import { PublicKey, type SpaceId } from '@dxos/keys';
+import { type SpaceId } from '@dxos/keys';
 import { type LevelDB } from '@dxos/kv-store';
 import { log } from '@dxos/log';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
-import { InvalidStorageVersionError, STORAGE_VERSION, trace } from '@dxos/protocols';
+import { InvalidStorageVersionError, STORAGE_VERSION } from '@dxos/protocols';
 import { FeedProtocol } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
@@ -42,6 +44,7 @@ import { safeInstanceof } from '@dxos/util';
 import { EdgeAgentManager } from '../agents';
 import {
   type CreateIdentityOptions,
+  type Identity,
   IdentityManager,
   type IdentityManagerProps,
   type JoinIdentityProps,
@@ -56,7 +59,6 @@ import {
   SpaceInvitationProtocol,
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeProps, type SigningContext } from '../spaces';
-
 import { FeedSyncer } from './feed-syncer';
 
 export type ServiceContextRuntimeProps = Pick<
@@ -74,7 +76,7 @@ export type ServiceContextRuntimeProps = Pick<
 // TODO(burdon): Rename/break-up into smaller components. And/or make members private.
 // TODO(dmaretskyi): Gets duplicated in CJS build between normal and testing bundles.
 @safeInstanceof('dxos.client-services.ServiceContext')
-@Trace.resource()
+@Trace.resource({ lifecycle: true })
 export class ServiceContext extends Resource {
   private readonly _edgeIdentityUpdateMutex = new Mutex();
 
@@ -90,7 +92,7 @@ export class ServiceContext extends Resource {
   public readonly invitationsManager: InvitationsManager;
   public readonly echoHost: EchoHost;
   private readonly _meshReplicator?: MeshEchoReplicator = undefined;
-  private readonly _echoEdgeReplicator?: EchoEdgeReplicator = undefined;
+  private readonly _echoEdgeReplicator?: EdgeAutomergeReplicator = undefined;
   private readonly _feedSyncer?: FeedSyncer = undefined;
 
   // Initialized after identity is initialized.
@@ -104,8 +106,6 @@ export class ServiceContext extends Resource {
 
   private _deviceSpaceSync?: CredentialProcessor;
 
-  private readonly _instanceId = PublicKey.random().toHex();
-
   constructor(
     public readonly storage: Storage,
     public readonly level: LevelDB,
@@ -169,8 +169,9 @@ export class ServiceContext extends Resource {
       peerIdProvider: () => this.identityManager.identity?.deviceKey?.toHex(),
       getSpaceKeyByRootDocumentId: (documentId) => this.spaceManager.findSpaceByRootDocumentId(documentId)?.key,
       runtime: this._runtime,
-      syncQueue: async (request) => {
-        return this._feedSyncer?.syncBlocking({
+      useSubduction: this._edgeFeatures?.subductionReplicator,
+      syncQueue: async (ctx, request) => {
+        return this._feedSyncer?.syncBlocking(ctx, {
           spaceId: request.spaceId as SpaceId,
           subspaceTag: request.subspaceTag,
           shouldPush: request.shouldPush,
@@ -205,11 +206,18 @@ export class ServiceContext extends Resource {
     if (!this._runtimeProps?.disableP2pReplication) {
       this._meshReplicator = new MeshEchoReplicator();
     }
-    if (this._edgeConnection && this._edgeFeatures?.echoReplicator && this._edgeHttpClient) {
-      this._echoEdgeReplicator = new EchoEdgeReplicator({
-        edgeConnection: this._edgeConnection,
-        edgeHttpClient: this._edgeHttpClient,
-      });
+    if (this._edgeConnection && this._edgeHttpClient) {
+      if (this._edgeFeatures?.subductionReplicator) {
+        this._echoEdgeReplicator = new EchoEdgeSubductionReplicator({
+          edgeConnection: this._edgeConnection,
+          edgeHttpClient: this._edgeHttpClient,
+        });
+      } else if (this._edgeFeatures?.echoReplicator) {
+        this._echoEdgeReplicator = new EchoEdgeReplicator({
+          edgeConnection: this._edgeConnection,
+          edgeHttpClient: this._edgeHttpClient,
+        });
+      }
     }
 
     if (this.echoHost.feedStore && this._edgeConnection) {
@@ -224,44 +232,75 @@ export class ServiceContext extends Resource {
     }
   }
 
-  @Trace.span()
+  @Trace.span({ op: 'lifecycle' })
   protected override async _open(ctx: Context): Promise<void> {
     await this._checkStorageVersion();
 
     log('opening...');
-    log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
 
+    log('opening identityManager...');
     await this.identityManager.open(ctx);
+    log('identityManager opened', { hasIdentity: !!this.identityManager.identity });
 
-    await this._setNetworkIdentity();
+    log('setting network identity...');
+    await this._setNetworkIdentity({ identity: this.identityManager.identity });
+    log('network identity set');
 
-    await this._edgeConnection?.open();
-    await this.signalManager.open();
+    log('opening edge connection...');
+    await this._edgeConnection?.open(ctx);
+    log('edge connection opened');
+
+    log('opening signal manager...');
+    await this.signalManager.open(ctx);
+    log('signal manager opened');
+
+    log('opening network manager...');
     await this.networkManager.open();
+    log('network manager opened');
 
+    log('opening echo host...');
     await this.echoHost.open(ctx);
+    log('echo host opened');
 
     if (this._meshReplicator) {
-      await this.echoHost.addReplicator(this._meshReplicator);
+      log('adding mesh replicator...');
+      await this.echoHost.addReplicator(ctx, this._meshReplicator);
+      log('mesh replicator added');
     }
     if (this._echoEdgeReplicator) {
-      await this.echoHost.addReplicator(this._echoEdgeReplicator);
+      log('adding edge replicator...');
+      await this.echoHost.addReplicator(ctx, this._echoEdgeReplicator);
+      log('edge replicator added');
     }
 
+    log('loading metadata store...');
     await this.metadataStore.load();
+    log('metadata store loaded');
+
+    log('opening space manager...');
     await this.spaceManager.open();
+    log('space manager opened');
 
     if (this.identityManager.identity) {
-      await this.identityManager.identity.joinNetwork();
+      log('joining network...');
+      await this.identityManager.identity.joinNetwork(ctx);
+      log('network joined');
+
+      log('initializing spaces...(calling _initialize)');
       await this._initialize(ctx);
+      log('spaces initialized');
+    } else {
+      log('no identity, skipping network join and space initialization');
     }
 
-    await this._feedSyncer?.open();
+    log('opening feed syncer...');
+    await this._feedSyncer?.open(ctx);
+    log('feed syncer opened');
 
-    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations();
+    log('loading persistent invitations...');
+    const loadedInvitations = await this.invitationsManager.loadPersistentInvitations(ctx);
     log('loaded persistent invitations', { count: loadedInvitations.invitations?.length });
 
-    log.trace('dxos.sdk.service-context.open', trace.end({ id: this._instanceId }));
     log('opened');
   }
 
@@ -273,13 +312,13 @@ export class ServiceContext extends Resource {
     if (this._deviceSpaceSync && this.identityManager.identity) {
       await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
     }
-    await this.dataSpaceManager?.close();
+    await this.dataSpaceManager?.close(ctx);
     await this.edgeAgentManager?.close();
-    await this.identityManager.close();
+    await this.identityManager.close(ctx);
     await this.spaceManager.close();
     await this.echoHost.close(ctx);
 
-    await this.networkManager.close();
+    await this.networkManager.close(ctx);
     await this.signalManager.close();
     await this._edgeConnection?.close();
     await this.feedStore.close();
@@ -288,11 +327,12 @@ export class ServiceContext extends Resource {
     log('closed');
   }
 
-  async createIdentity(params: CreateIdentityOptions = {}) {
-    const identity = await this.identityManager.createIdentity(params);
-    await this._setNetworkIdentity();
-    await identity.joinNetwork();
-    await this._initialize(new Context());
+  async createIdentity(params: CreateIdentityOptions = {}, ctx?: Context) {
+    ctx ??= this._ctx;
+    const identity = await this.identityManager.createIdentity(params, ctx);
+    await this._setNetworkIdentity({ identity });
+    await identity.joinNetwork(ctx);
+    await this._initialize(ctx);
     return identity;
   }
 
@@ -316,11 +356,11 @@ export class ServiceContext extends Resource {
   }
 
   private async _acceptIdentity(params: JoinIdentityProps) {
-    const { identity, identityRecord } = await this.identityManager.prepareIdentity(params);
-    await this._setNetworkIdentity({ deviceCredential: params.authorizedDeviceCredential! });
-    await identity.joinNetwork();
+    const { identity, identityRecord } = await this.identityManager.prepareIdentity(params, this._ctx);
+    await this._setNetworkIdentity({ deviceCredential: params.authorizedDeviceCredential!, identity });
+    await identity.joinNetwork(this._ctx);
     await this.identityManager.acceptIdentity(identity, identityRecord, params.deviceProfile);
-    await this._initialize(new Context());
+    await this._initialize(this._ctx);
     return identity;
   }
 
@@ -335,7 +375,7 @@ export class ServiceContext extends Resource {
   // Called when identity is created.
   @Trace.span()
   private async _initialize(ctx: Context): Promise<void> {
-    log('initializing spaces...');
+    log('_initialize: start');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
       credentialSigner: identity.getIdentityCredentialSigner(),
@@ -347,6 +387,7 @@ export class ServiceContext extends Resource {
       },
     };
 
+    log('_initialize: creating DataSpaceManager');
     this.dataSpaceManager = new DataSpaceManager({
       spaceManager: this.spaceManager,
       metadataStore: this.metadataStore,
@@ -362,7 +403,9 @@ export class ServiceContext extends Resource {
       runtimeProps: this._runtimeProps as DataSpaceManagerRuntimeProps,
       edgeFeatures: this._edgeFeatures,
     });
-    await this.dataSpaceManager.open();
+    log('_initialize: opening DataSpaceManager...');
+    await this.dataSpaceManager.open(ctx);
+    log('_initialize: DataSpaceManager opened');
 
     this.edgeAgentManager = new EdgeAgentManager(
       this._edgeFeatures,
@@ -370,13 +413,16 @@ export class ServiceContext extends Resource {
       this.dataSpaceManager,
       identity,
     );
-    await this.edgeAgentManager.open();
+    log('_initialize: opening EdgeAgentManager...');
+    await this.edgeAgentManager.open(ctx);
+    log('_initialize: EdgeAgentManager opened');
 
     this._handlerFactories.set(Invitation.Kind.SPACE, (invitation) => {
       invariant(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
       return new SpaceInvitationProtocol(this.dataSpaceManager, signingContext, this.keyring, invitation.spaceKey);
     });
     this.initialized.wake();
+    log('_initialize: initialized.wake() called');
 
     this._deviceSpaceSync = {
       processCredential: async (credential: Credential) => {
@@ -399,9 +445,10 @@ export class ServiceContext extends Resource {
 
         try {
           log('accepting space recorded in halo', { details: assertion });
-          await this.dataSpaceManager.acceptSpace({
+          await this.dataSpaceManager.acceptSpace(this._ctx, {
             spaceKey: assertion.spaceKey,
             genesisFeedKey: assertion.genesisFeedKey,
+            tags: assertion.tags,
           });
         } catch (err) {
           log.catch(err);
@@ -412,33 +459,42 @@ export class ServiceContext extends Resource {
     await identity.space.spaceState.addCredentialProcessor(this._deviceSpaceSync);
   }
 
-  private async _setNetworkIdentity(params?: { deviceCredential: Credential }): Promise<void> {
+  private async _setNetworkIdentity(params?: { deviceCredential?: Credential; identity?: Identity }): Promise<void> {
+    log('_setNetworkIdentity: acquiring mutex...');
     using _ = await this._edgeIdentityUpdateMutex.acquire();
+    log('_setNetworkIdentity: mutex acquired');
 
     let edgeIdentity: EdgeIdentity;
-    const identity = this.identityManager.identity;
+    const identity = params?.identity;
     if (identity) {
-      log('setting identity on edge connection', {
+      log('_setNetworkIdentity: has identity', {
         identity: identity.identityKey.toHex(),
-        swarms: this.networkManager.topics,
+        hasDeviceCredential: !!params?.deviceCredential,
       });
 
       if (params?.deviceCredential) {
+        log('_setNetworkIdentity: creating chain edge identity with device credential...');
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,
           identity.identityKey,
           identity.deviceKey,
-          params?.deviceCredential && { credential: params.deviceCredential },
+          { credential: params.deviceCredential },
           [], // TODO(dmaretskyi): Service access credentials.
         );
+        log('_setNetworkIdentity: chain edge identity created');
       } else {
+        log('_setNetworkIdentity: waiting for identity.ready()...');
         // TODO: throw here or from identity if device chain can't be loaded, to avoid indefinite hangup
         await warnAfterTimeout(10_000, 'Waiting for identity to be ready for edge connection', async () => {
           await identity.ready();
         });
+        log('_setNetworkIdentity: identity.ready() resolved', {
+          hasDeviceCredentialChain: !!identity.deviceCredentialChain,
+        });
 
         invariant(identity.deviceCredentialChain);
 
+        log('_setNetworkIdentity: creating chain edge identity...');
         edgeIdentity = await createChainEdgeIdentity(
           identity.signer,
           identity.identityKey,
@@ -446,9 +502,12 @@ export class ServiceContext extends Resource {
           identity.deviceCredentialChain,
           [], // TODO(dmaretskyi): Service access credentials.
         );
+        log('_setNetworkIdentity: chain edge identity created');
       }
     } else {
+      log('_setNetworkIdentity: no identity, creating ephemeral edge identity...');
       edgeIdentity = await createEphemeralEdgeIdentity();
+      log('_setNetworkIdentity: ephemeral edge identity created');
     }
 
     this._edgeConnection?.setIdentity(edgeIdentity);
@@ -457,5 +516,6 @@ export class ServiceContext extends Resource {
       identityKey: edgeIdentity.identityKey,
       peerKey: edgeIdentity.peerKey,
     });
+    log('_setNetworkIdentity: done');
   }
 }