@dxos/network-manager 0.8.4-main.84f28bd → 0.8.4-main.8baae0fced

package/src/signal/swarm-messenger.ts

@@ -7,7 +7,7 @@ import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { type PeerInfo, type Message } from '@dxos/messaging';
+import { type Message, type PeerInfo } from '@dxos/messaging';
 import { TimeoutError } from '@dxos/protocols';
 import { schema } from '@dxos/protocols/proto';
 import { type Answer, type SwarmMessage } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -20,9 +20,9 @@ interface OfferRecord {
 }
 
 export type SwarmMessengerOptions = {
-  sendMessage: (params: Message) => Promise<void>;
-  onOffer: (message: OfferMessage) => Promise<Answer>;
-  onSignal: (message: SignalMessage) => Promise<void>;
+  sendMessage: (ctx: Context, params: Message) => Promise<void>;
+  onOffer: (ctx: Context, message: OfferMessage) => Promise<Answer>;
+  onSignal: (ctx: Context, message: SignalMessage) => Promise<void>;
   topic: PublicKey;
 };
 
@@ -32,11 +32,9 @@ const SwarmMessage = schema.getCodecForType('dxos.mesh.swarm.SwarmMessage');
  * Adds offer/answer and signal interfaces.
  */
 export class SwarmMessenger implements SignalMessenger {
-  private readonly _ctx = new Context();
-
-  private readonly _sendMessage: (msg: Message) => Promise<void>;
-  private readonly _onSignal: (message: SignalMessage) => Promise<void>;
-  private readonly _onOffer: (message: OfferMessage) => Promise<Answer>;
+  private readonly _sendMessage: SwarmMessengerOptions['sendMessage'];
+  private readonly _onSignal: SwarmMessengerOptions['onSignal'];
+  private readonly _onOffer: SwarmMessengerOptions['onOffer'];
   private readonly _topic: PublicKey;
 
   private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap((key) => key.toHex());
@@ -48,15 +46,18 @@ export class SwarmMessenger implements SignalMessenger {
     this._topic = topic;
   }
 
-  async receiveMessage({
-    author,
-    recipient,
-    payload,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    payload: Any;
-  }): Promise<void> {
+  async receiveMessage(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      payload,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      payload: Any;
+    },
+  ): Promise<void> {
     if (payload.type_url !== 'dxos.mesh.swarm.SwarmMessage') {
       // Ignore not swarm messages.
       return;
@@ -71,35 +72,35 @@ export class SwarmMessenger implements SignalMessenger {
     log('received', { from: author, to: recipient, msg: message });
 
     if (message.data?.offer) {
-      await this._handleOffer({ author, recipient, message });
+      await this._handleOffer(ctx, { author, recipient, message });
     } else if (message.data?.answer) {
       await this._resolveAnswers(message);
     } else if (message.data?.signal) {
-      await this._handleSignal({ author, recipient, message });
+      await this._handleSignal(ctx, { author, recipient, message });
     } else if (message.data?.signalBatch) {
-      await this._handleSignal({ author, recipient, message });
+      await this._handleSignal(ctx, { author, recipient, message });
     } else {
       log.warn('unknown message', { message });
     }
   }
 
-  async signal(message: SignalMessage): Promise<void> {
+  async signal(ctx: Context, message: SignalMessage): Promise<void> {
     invariant(message.data?.signal || message.data?.signalBatch, 'Invalid message');
-    await this._sendReliableMessage({
+    await this._sendReliableMessage(ctx, {
       author: message.author,
       recipient: message.recipient,
       message,
     });
   }
 
-  async offer(message: OfferMessage): Promise<Answer> {
+  async offer(ctx: Context, message: OfferMessage): Promise<Answer> {
     const networkMessage: SwarmMessage = {
       ...message,
       messageId: PublicKey.random(),
     };
     return new Promise<Answer>((resolve, reject) => {
       this._offerRecords.set(networkMessage.messageId!, { resolve });
-      this._sendReliableMessage({
+      this._sendReliableMessage(ctx, {
         author: message.author,
         recipient: message.recipient,
         message: networkMessage,
@@ -107,15 +108,18 @@ export class SwarmMessenger implements SignalMessenger {
     });
   }
 
-  private async _sendReliableMessage({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: MakeOptional<SwarmMessage, 'messageId'>;
-  }): Promise<void> {
+  private async _sendReliableMessage(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: MakeOptional<SwarmMessage, 'messageId'>;
+    },
+  ): Promise<void> {
     const networkMessage: SwarmMessage = {
       ...message,
       // Setting unique message_id if it not specified yet.
@@ -123,7 +127,7 @@ export class SwarmMessenger implements SignalMessenger {
     };
 
     log('sending', { from: author, to: recipient, msg: networkMessage });
-    await this._sendMessage({
+    await this._sendMessage(ctx, {
       author,
       recipient,
       payload: {
@@ -144,15 +148,18 @@ export class SwarmMessenger implements SignalMessenger {
     }
   }
 
-  private async _handleOffer({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: SwarmMessage;
-  }): Promise<void> {
+  private async _handleOffer(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: SwarmMessage;
+    },
+  ): Promise<void> {
     invariant(message.data.offer, 'No offer');
     const offerMessage: OfferMessage = {
       author,
@@ -160,10 +167,10 @@ export class SwarmMessenger implements SignalMessenger {
       ...message,
       data: { offer: message.data.offer },
     };
-    const answer = await this._onOffer(offerMessage);
+    const answer = await this._onOffer(ctx, offerMessage);
     answer.offerMessageId = message.messageId;
     try {
-      await this._sendReliableMessage({
+      await this._sendReliableMessage(ctx, {
         author: recipient,
         recipient: author,
         message: {
@@ -181,15 +188,18 @@ export class SwarmMessenger implements SignalMessenger {
     }
   }
 
-  private async _handleSignal({
-    author,
-    recipient,
-    message,
-  }: {
-    author: PeerInfo;
-    recipient: PeerInfo;
-    message: SwarmMessage;
-  }): Promise<void> {
+  private async _handleSignal(
+    ctx: Context,
+    {
+      author,
+      recipient,
+      message,
+    }: {
+      author: PeerInfo;
+      recipient: PeerInfo;
+      message: SwarmMessage;
+    },
+  ): Promise<void> {
     invariant(message.messageId);
     invariant(message.data.signal || message.data.signalBatch, 'Invalid message');
     const signalMessage: SignalMessage = {
@@ -202,6 +212,6 @@ export class SwarmMessenger implements SignalMessenger {
       },
     };
 
-    await this._onSignal(signalMessage);
+    await this._onSignal(ctx, signalMessage);
   }
 }

package/src/swarm/connection.test.ts

@@ -7,12 +7,13 @@ import { describe, test } from 'vitest';
 import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 
-import { Connection } from './connection';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { createRtcTransportFactory } from '../transport';
 import { chooseInitiatorPeer } from '../transport/webrtc/utils';
+import { Connection } from './connection';
 
-describe('Connection', () => {
+// Segfault in node-datachannel.
+describe.skip('Connection', () => {
   test('responder opens after initiator', async () => {
     const { initiator, responder } = createPeerKeys();
     await connectionTest({
@@ -42,9 +43,9 @@ describe('Connection', () => {
       sessionId,
       true,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await fastConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await fastConnection.signal(ctx, msg);
         },
       },
       slowPeerProtocol.factory({
@@ -64,9 +65,9 @@ describe('Connection', () => {
       sessionId,
       false,
       {
-        offer: async (msg) => ({ accept: true }),
-        signal: async (msg) => {
-          await slowConnection.signal(msg);
+        offer: async (_ctx, _msg) => ({ accept: true }),
+        signal: async (ctx, msg) => {
+          await slowConnection.signal(ctx, msg);
         },
       },
       fastPeerProtocol.factory({

package/src/swarm/connection.ts

@@ -2,21 +2,14 @@
 // Copyright 2021 DXOS.org
 //
 
-import { DeferredTask, Event, sleep, scheduleTask, scheduleTaskInterval, synchronized, Trigger } from '@dxos/async';
-import { Context, cancelWithContext, ContextDisposedError } from '@dxos/context';
+import { DeferredTask, Event, Trigger, scheduleTask, scheduleTaskInterval, sleep, synchronized } from '@dxos/async';
+import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import { ErrorStream } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log, logInfo } from '@dxos/log';
 import { type PeerInfo } from '@dxos/messaging';
-import {
-  CancelledError,
-  ProtocolError,
-  ConnectionResetError,
-  ConnectivityError,
-  TimeoutError,
-  trace,
-} from '@dxos/protocols';
+import { CancelledError, ConnectionResetError, ConnectivityError, ProtocolError, TimeoutError } from '@dxos/protocols';
 import { type Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
 import { type SignalMessage, type SignalMessenger } from '../signal';
@@ -113,12 +106,10 @@ export class Connection {
   readonly stateChanged = new Event<ConnectionState>();
   readonly errors = new ErrorStream();
 
-  public _instanceId = PublicKey.random().toHex();
-
   public readonly transportStats = new Event<TransportStats>();
 
   private readonly _signalSendTask = new DeferredTask(this._ctx, async () => {
-    await this._flushSignalBuffer();
+    await this._flushSignalBuffer(this._ctx);
   });
 
   private _signallingDelay = STARTING_SIGNALLING_DELAY;
@@ -165,7 +156,7 @@ export class Connection {
    */
   async openConnection(): Promise<void> {
     invariant(this._state === ConnectionState.INITIAL, 'Invalid state.');
-    log.trace('dxos.mesh.connection.open-connection', trace.begin({ id: this._instanceId }));
+    log('opening connection');
     log.trace('dxos.mesh.connection.open', {
       sessionId: this.sessionId,
       topic: this.topic,
@@ -185,16 +176,18 @@ export class Connection {
     this._protocol.stream.on('close', () => {
       log('protocol stream closed');
       this._protocolClosed.wake();
-      this.close({ error: new ProtocolError('protocol stream closed') }).catch((err) => this.errors.raise(err));
+      this.close({ error: new ProtocolError({ message: 'protocol stream closed' }) }).catch((err) =>
+        this.errors.raise(err),
+      );
     });
 
     scheduleTask(
       this.connectedTimeoutContext,
       async () => {
         log.info(`timeout waiting ${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect, aborting`);
-        await this.abort(new TimeoutError(`${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect`)).catch(
-          (err) => this.errors.raise(err),
-        );
+        await this.abort(
+          new TimeoutError({ message: `${TRANSPORT_CONNECTION_TIMEOUT / 1000}s for transport to connect` }),
+        ).catch((err) => this.errors.raise(err));
       },
       TRANSPORT_CONNECTION_TIMEOUT,
     );
@@ -255,7 +248,7 @@ export class Connection {
 
     this._incomingSignalBuffer = [];
 
-    log.trace('dxos.mesh.connection.open-connection', trace.end({ id: this._instanceId }));
+    log('opened connection');
   }
 
   @synchronized
@@ -364,21 +357,21 @@ export class Connection {
     this._signalSendTask.schedule();
   }
 
-  private async _flushSignalBuffer(): Promise<void> {
+  private async _flushSignalBuffer(ctx: Context): Promise<void> {
     if (this._outgoingSignalBuffer.length === 0) {
       return;
     }
 
     try {
       if (process.env.NODE_ENV !== 'test') {
-        await cancelWithContext(this._ctx, sleep(this._signallingDelay));
+        await cancelWithContext(ctx, sleep(this._signallingDelay));
         this._signallingDelay = Math.min(this._signallingDelay * 2, MAX_SIGNALLING_DELAY);
       }
 
       const signals = [...this._outgoingSignalBuffer];
       this._outgoingSignalBuffer.length = 0;
 
-      await this._signalMessaging.signal({
+      await this._signalMessaging.signal(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId: this.sessionId,
@@ -397,14 +390,14 @@ export class Connection {
 
       // If signal fails treat connection as failed
       log.info('signal message failed to deliver', { err });
-      await this.close({ error: new ConnectivityError('signal message failed to deliver', err) });
+      await this.close({ error: new ConnectivityError({ message: 'signal message failed to deliver', cause: err }) });
     }
   }
 
   /**
    * Receive a signal from the remote peer.
    */
-  async signal(msg: SignalMessage): Promise<void> {
+  async signal(_ctx: Context, msg: SignalMessage): Promise<void> {
     invariant(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('dropping signal for incorrect session id');
@@ -414,7 +407,7 @@ export class Connection {
     invariant(msg.author.peerKey === this.remoteInfo.peerKey);
     invariant(msg.recipient.peerKey === this.localInfo.peerKey);
 
-    const signals = msg.data.signalBatch ? msg.data.signalBatch.signals ?? [] : [msg.data.signal];
+    const signals = msg.data.signalBatch ? (msg.data.signalBatch.signals ?? []) : [msg.data.signal];
     for (const signal of signals) {
       if (!signal) {
         continue;

package/src/swarm/peer.ts

@@ -11,15 +11,15 @@ import { type PeerInfo } from '@dxos/messaging';
 import { CancelledError, SystemError } from '@dxos/protocols';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 
-import { Connection, ConnectionState } from './connection';
-import { type ConnectionLimiter } from './connection-limiter';
 import { type OfferMessage, type SignalMessage, type SignalMessenger } from '../signal';
 import { type TransportFactory } from '../transport';
 import { type WireProtocolProvider } from '../wire-protocol';
+import { Connection, ConnectionState } from './connection';
+import { type ConnectionLimiter } from './connection-limiter';
 
 export class ConnectionDisplacedError extends SystemError {
   constructor() {
-    super('Connection displaced by remote initiator.');
+    super({ message: 'Connection displaced by remote initiator.' });
   }
 }
 
@@ -105,7 +105,7 @@ export class Peer {
   /**
    * Respond to remote offer.
    */
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(_ctx: Context, message: OfferMessage): Promise<Answer> {
     const remote = message.author;
 
     if (
@@ -161,13 +161,14 @@ export class Peer {
         return { accept: true };
       }
     }
+
     return { accept: false };
   }
 
   /**
    * Initiate a connection to the remote peer.
    */
-  async initiateConnection(): Promise<void> {
+  async initiateConnection(ctx: Context): Promise<void> {
     invariant(!this.initiating, 'Initiation in progress.');
     invariant(!this.connection, 'Already connected.');
     const sessionId = PublicKey.random();
@@ -181,7 +182,7 @@ export class Peer {
       await this._connectionLimiter.connecting(sessionId);
       connection.initiate();
 
-      answer = await this._signalMessaging.offer({
+      answer = await this._signalMessaging.offer(ctx, {
         author: this.localInfo,
         recipient: this.remoteInfo,
         sessionId,
@@ -376,13 +377,13 @@ export class Peer {
     log('closed', { peerId: this.remoteInfo, sessionId: connection.sessionId });
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     if (!this.connection) {
       log('dropping signal message for non-existent connection', { message });
       return;
     }
 
-    await this.connection.signal(message);
+    await this.connection.signal(ctx, message);
   }
 
   @synchronized

package/src/swarm/swarm-mapper.ts

@@ -5,7 +5,7 @@
 import { type CleanupFn, Event, SubscriptionList } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { PeerInfoHash, type PeerInfo as MessagingPeer } from '@dxos/messaging';
+import { type PeerInfo as MessagingPeer, PeerInfoHash } from '@dxos/messaging';
 import { ComplexMap } from '@dxos/util';
 
 import { type ConnectionState } from './connection';

package/src/swarm/swarm.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
@@ -15,12 +15,12 @@ import {
 } from '@dxos/messaging';
 import { ComplexSet } from '@dxos/util';
 
-import { ConnectionState } from './connection';
-import { ConnectionLimiter } from './connection-limiter';
-import { Swarm } from './swarm';
 import { TestWireProtocol } from '../testing/test-wire-protocol';
 import { FullyConnectedTopology } from '../topology';
 import { createRtcTransportFactory } from '../transport';
+import { ConnectionState } from './connection';
+import { ConnectionLimiter } from './connection-limiter';
+import { Swarm } from './swarm';
 
 type TestPeer = {
   swarm: Swarm;
@@ -30,7 +30,8 @@ type TestPeer = {
   signalManager: SignalManager;
 };
 
-describe('Swarm', () => {
+// Segfault in node-datachannel.
+describe.skip('Swarm', () => {
   const context = new MemorySignalManagerContext();
 
   const setupSwarm = async ({
@@ -157,9 +158,9 @@ describe('Swarm', () => {
     const messages = new ComplexSet<{ author: PeerInfo; recipient: PeerInfo }>(
       ({ author, recipient }) => author.peerKey + recipient.peerKey,
     );
-    signalManager.sendMessage = async (message) => {
+    signalManager.sendMessage = async (ctx, message) => {
       messages.add({ author: message.author, recipient: message.recipient });
-      return sendOriginal(message);
+      return sendOriginal(ctx, message);
     };
     // Stop signaling to stop connection in initiation state.
     signalManager.freeze();

package/src/swarm/swarm.ts

@@ -8,19 +8,18 @@ import { ErrorStream } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log, logInfo } from '@dxos/log';
-import { type SwarmEvent, type ListeningHandle, type Messenger, type PeerInfo, PeerInfoHash } from '@dxos/messaging';
-import { trace } from '@dxos/protocols';
+import { type ListeningHandle, type Messenger, type PeerInfo, PeerInfoHash, type SwarmEvent } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap, isNonNullable } from '@dxos/util';
 
-import { type Connection, ConnectionState } from './connection';
-import { type ConnectionLimiter } from './connection-limiter';
-import { Peer } from './peer';
 import { type OfferMessage, type SignalMessage, SwarmMessenger } from '../signal';
 import { type SwarmController, type Topology } from '../topology';
 import { type TransportFactory } from '../transport';
 import { type Topic } from '../types';
 import { type WireProtocolProvider } from '../wire-protocol';
+import { type Connection, ConnectionState } from './connection';
+import { type ConnectionLimiter } from './connection-limiter';
+import { Peer } from './peer';
 
 const INITIATION_DELAY = 100;
 
@@ -85,20 +84,15 @@ export class Swarm {
     private readonly _connectionLimiter: ConnectionLimiter,
     private readonly _initiationDelay = INITIATION_DELAY,
   ) {
-    log.trace(
-      'dxos.mesh.swarm.constructor',
-      trace.begin({ id: this._instanceId, data: { topic: this._topic.toHex(), peer: this._ownPeer } }),
-    );
-    log('creating swarm', { peerId: _ownPeer });
+    log('creating swarm', { topic: this._topic.toHex(), peer: this._ownPeer });
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new SwarmMessenger({
-      sendMessage: async (msg) => await this._messenger.sendMessage(msg),
-      onSignal: async (msg) => await this.onSignal(msg),
-      onOffer: async (msg) => await this.onOffer(msg),
+      sendMessage: async (ctx, msg) => await this._messenger.sendMessage(ctx, msg),
+      onSignal: async (ctx, msg) => await this.onSignal(ctx, msg),
+      onOffer: async (ctx, msg) => await this.onOffer(ctx, msg),
       topic: this._topic,
     });
-    log.trace('dxos.mesh.swarm.constructor', trace.end({ id: this._instanceId }));
   }
 
   get connections() {
@@ -135,7 +129,7 @@ export class Swarm {
       payloadType: 'dxos.mesh.swarm.SwarmMessage',
       onMessage: async (message) => {
         await this._swarmMessenger
-          .receiveMessage(message)
+          .receiveMessage(this._ctx, message)
           // TODO(nf): discriminate between errors
           .catch((err) => log.info('Error while receiving message', { err }));
       },
@@ -204,7 +198,7 @@ export class Swarm {
   }
 
   @synchronized
-  async onOffer(message: OfferMessage): Promise<Answer> {
+  async onOffer(ctx: Context, message: OfferMessage): Promise<Answer> {
     log('offer', { message });
     if (this._ctx.disposed) {
       log('ignored for disposed swarm');
@@ -223,7 +217,7 @@ export class Swarm {
     }
 
     const peer = this._getOfferSenderPeer(message.author);
-    const answer = await peer.onOffer(message);
+    const answer = await peer.onOffer(ctx, message);
     this._topology.update();
     return answer;
   }
@@ -242,7 +236,7 @@ export class Swarm {
     return peer;
   }
 
-  async onSignal(message: SignalMessage): Promise<void> {
+  async onSignal(ctx: Context, message: SignalMessage): Promise<void> {
     log('signal', { message });
     if (this._ctx.disposed) {
       log.info('ignored for offline swarm');
@@ -256,7 +250,7 @@ export class Swarm {
     invariant(message.author);
 
     const peer = this._getOrCreatePeer(message.author);
-    await peer.onSignal(message);
+    await peer.onSignal(ctx, message);
   }
 
   // For debug purposes
@@ -403,7 +397,7 @@ export class Swarm {
     }
 
     log('initiating connection...', { remotePeer });
-    await peer.initiateConnection();
+    await peer.initiateConnection(ctx);
     this._topology.update();
     log('initiated', { remotePeer });
   }

package/src/testing/test-builder.ts

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -13,15 +14,22 @@ import {
 import { schema } from '@dxos/protocols/proto';
 import { ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
-import { createLinkedPorts, createProtoRpcPeer, type ProtoRpcPeer } from '@dxos/rpc';
+import { type ProtoRpcPeer, createLinkedPorts, createProtoRpcPeer } from '@dxos/rpc';
 import { ComplexMap } from '@dxos/util';
 
 import { TcpTransportFactory } from '#tcp-transport';
-import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
+
 import { SwarmNetworkManager } from '../network-manager';
 import { FullyConnectedTopology } from '../topology';
-import { MemoryTransportFactory, type TransportFactory, TransportKind } from '../transport';
-import { createRtcTransportFactory, RtcTransportProxyFactory, RtcTransportService } from '../transport';
+import {
+  MemoryTransportFactory,
+  RtcTransportProxyFactory,
+  RtcTransportService,
+  type TransportFactory,
+  TransportKind,
+  createRtcTransportFactory,
+} from '../transport';
+import { type TestTeleportExtensionFactory, TestWireProtocol } from './test-wire-protocol';
 
 // Signal server will be started by the setup script.
 const port = process.env.SIGNAL_PORT ?? 4000;
@@ -161,7 +169,7 @@ export class TestPeer {
 
     await this._proxy?.close();
     await this._service?.close();
-    await this._networkManager.close();
+    await this._networkManager.close(Context.default());
   }
 
   getSwarm(topic: PublicKey): TestSwarmConnection {
@@ -210,7 +218,7 @@ export class TestSwarmConnection {
   // TODO(burdon): Need to create new plugin instance per swarm?
   //  If so, then perhaps joinSwarm should return swarm object with access to plugins.
   async join(topology = new FullyConnectedTopology()): Promise<this> {
-    await this.peer._networkManager.joinSwarm({
+    await this.peer._networkManager.joinSwarm(Context.default(), {
       topic: this.topic,
       peerInfo: { peerKey: this.peer.peerId.toHex(), identityKey: this.peer.peerId.toHex() },
       protocolProvider: this.protocol.factory,
@@ -221,7 +229,7 @@ export class TestSwarmConnection {
   }
 
   async leave(): Promise<this> {
-    await this.peer._networkManager.leaveSwarm(this.topic);
+    await this.peer._networkManager.leaveSwarm(Context.default(), this.topic);
     return this;
   }
 }