@dxos/network-manager 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/network-manager",
-  "version": "0.8.4-main.bc674ce",
+  "version": "0.8.4-main.bcb3aa67d6",
   "description": "Network Manager",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -81,26 +81,26 @@
   ],
   "dependencies": {
     "node-datachannel": "^0.30.0",
-    "@dxos/async": "0.8.4-main.bc674ce",
-    "@dxos/context": "0.8.4-main.bc674ce",
-    "@dxos/debug": "0.8.4-main.bc674ce",
-    "@dxos/codec-protobuf": "0.8.4-main.bc674ce",
-    "@dxos/invariant": "0.8.4-main.bc674ce",
-    "@dxos/log": "0.8.4-main.bc674ce",
-    "@dxos/keys": "0.8.4-main.bc674ce",
-    "@dxos/messaging": "0.8.4-main.bc674ce",
-    "@dxos/protocols": "0.8.4-main.bc674ce",
-    "@dxos/node-std": "0.8.4-main.bc674ce",
-    "@dxos/rpc": "0.8.4-main.bc674ce",
-    "@dxos/util": "0.8.4-main.bc674ce",
-    "@dxos/tracing": "0.8.4-main.bc674ce",
-    "@dxos/teleport": "0.8.4-main.bc674ce"
+    "@dxos/async": "0.8.4-main.bcb3aa67d6",
+    "@dxos/codec-protobuf": "0.8.4-main.bcb3aa67d6",
+    "@dxos/debug": "0.8.4-main.bcb3aa67d6",
+    "@dxos/invariant": "0.8.4-main.bcb3aa67d6",
+    "@dxos/context": "0.8.4-main.bcb3aa67d6",
+    "@dxos/keys": "0.8.4-main.bcb3aa67d6",
+    "@dxos/messaging": "0.8.4-main.bcb3aa67d6",
+    "@dxos/log": "0.8.4-main.bcb3aa67d6",
+    "@dxos/node-std": "0.8.4-main.bcb3aa67d6",
+    "@dxos/rpc": "0.8.4-main.bcb3aa67d6",
+    "@dxos/teleport": "0.8.4-main.bcb3aa67d6",
+    "@dxos/tracing": "0.8.4-main.bcb3aa67d6",
+    "@dxos/util": "0.8.4-main.bcb3aa67d6",
+    "@dxos/protocols": "0.8.4-main.bcb3aa67d6"
   },
   "devDependencies": {
     "fetch-mock": "^11.0.0",
-    "@dxos/edge-client": "0.8.4-main.bc674ce",
-    "@dxos/keyring": "0.8.4-main.bc674ce",
-    "@dxos/signal": "0.8.4-main.bc674ce"
+    "@dxos/edge-client": "0.8.4-main.bcb3aa67d6",
+    "@dxos/keyring": "0.8.4-main.bcb3aa67d6",
+    "@dxos/signal": "0.8.4-main.bcb3aa67d6"
   },
   "publishConfig": {
     "access": "public"

package/src/network-manager.ts

@@ -3,6 +3,7 @@
 //
 
 import { Event, synchronized } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -21,7 +22,7 @@ import { type WireProtocolProvider } from './wire-protocol';
  * Represents a single connection to a remote peer.
  */
 export type SwarmConnection = {
-  close(): Promise<void>;
+  close(ctx: Context): Promise<void>;
 };
 
 // TODO(burdon): Add timeout.
@@ -91,8 +92,8 @@ export class SwarmNetworkManager {
     this._signalManager.swarmEvent.on((event) => this._swarms.get(event.topic)?.onSwarmEvent(event));
     this._messenger = new Messenger({ signalManager: this._signalManager });
     this._signalConnection = {
-      join: (opts) => this._signalManager.join(opts),
-      leave: (opts) => this._signalManager.leave(opts),
+      join: (ctx, opts) => this._signalManager.join(ctx, opts),
+      leave: (ctx, opts) => this._signalManager.leave(ctx, opts),
     };
     this._peerInfo = peerInfo;
 
@@ -136,9 +137,9 @@ export class SwarmNetworkManager {
     log.trace('dxos.mesh.network-manager.open', trace.end({ id: this._instanceId }));
   }
 
-  async close(): Promise<void> {
+  async close(ctx: Context): Promise<void> {
     for (const topic of this._swarms.keys()) {
-      await this.leaveSwarm(topic).catch((err) => {
+      await this.leaveSwarm(ctx, topic).catch((err) => {
         log(err);
       });
     }
@@ -151,12 +152,15 @@ export class SwarmNetworkManager {
    * Join the swarm.
    */
   @synchronized
-  async joinSwarm({
-    topic, //
-    topology,
-    protocolProvider: protocol,
-    label,
-  }: SwarmOptions): Promise<SwarmConnection> {
+  async joinSwarm(
+    ctx: Context,
+    {
+      topic, //
+      topology,
+      protocolProvider: protocol,
+      label,
+    }: SwarmOptions,
+  ): Promise<SwarmConnection> {
     invariant(PublicKey.isPublicKey(topic));
     invariant(topology);
     invariant(this._peerInfo);
@@ -187,14 +191,14 @@ export class SwarmNetworkManager {
     // Open before joining.
     await swarm.open();
 
-    this._signalConnection.join({ topic, peer: this._peerInfo }).catch((error) => log.catch(error));
+    this._signalConnection.join(ctx, { topic, peer: this._peerInfo }).catch((error) => log.catch(error));
 
     this.topicsUpdated.emit();
     this._connectionLog?.joinedSwarm(swarm);
     log('joined', { topic: PublicKey.from(topic), count: this._swarms.size });
 
     return {
-      close: () => this.leaveSwarm(topic),
+      close: (ctx: Context) => this.leaveSwarm(ctx, topic),
     };
   }
 
@@ -202,7 +206,7 @@ export class SwarmNetworkManager {
    * Close the connection.
    */
   @synchronized
-  async leaveSwarm(topic: PublicKey): Promise<void> {
+  async leaveSwarm(ctx: Context, topic: PublicKey): Promise<void> {
     if (!this._swarms.has(topic)) {
       // log.warn('swarm not open', { topic: PublicKey.from(topic).truncate() });
       return;
@@ -210,7 +214,7 @@ export class SwarmNetworkManager {
 
     log('leaving', { topic: PublicKey.from(topic) });
     const swarm = this._swarms.get(topic)!;
-    await this._signalConnection.leave({ topic, peer: swarm.ownPeer });
+    await this._signalConnection.leave(ctx, { topic, peer: swarm.ownPeer });
 
     const map = this._mappers.get(topic)!;
     map.destroy();

package/src/signal/integration.node.test.ts

@@ -4,6 +4,7 @@
 
 import { afterAll, beforeAll, describe, expect, onTestFinished, test } from 'vitest';
 
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { Messenger, type PeerInfo, WebsocketSignalManager } from '@dxos/messaging';
 import { type SignalServerRunner, runTestSignalServer } from '@dxos/signal';
@@ -42,17 +43,17 @@ describe('Signal Integration Test', () => {
     onTestFinished(() => messenger.close());
     await messenger.listen({
       peer,
-      onMessage: async (message) => await messageRouter.receiveMessage(message),
+      onMessage: async (message) => await messageRouter.receiveMessage(Context.default(), message),
     });
 
     const receivedSignals: SignalMessage[] = [];
-    const signalMock = async (msg: SignalMessage) => {
+    const signalMock = async (_ctx: Context, msg: SignalMessage) => {
       receivedSignals.push(msg);
     };
     const messageRouter = new SwarmMessenger({
-      sendMessage: messenger.sendMessage.bind(messenger),
+      sendMessage: (ctx, message) => messenger.sendMessage(ctx, message),
       onSignal: signalMock,
-      onOffer: async () => ({ accept: true }),
+      onOffer: async (_ctx) => ({ accept: true }),
       topic,
     });
 
@@ -78,14 +79,14 @@ describe('Signal Integration Test', () => {
       ({ peerAvailable }) => !!peerAvailable && peerNetworking1.peer.peerKey === peerAvailable.peer.peerKey,
     );
 
-    await peerNetworking1.signalManager.join({ topic, peer: peerNetworking1.peer });
-    await peerNetworking2.signalManager.join({ topic, peer: peerNetworking2.peer });
+    await peerNetworking1.signalManager.join(Context.default(), { topic, peer: peerNetworking1.peer });
+    await peerNetworking2.signalManager.join(Context.default(), { topic, peer: peerNetworking2.peer });
 
     await promise1;
     await promise2;
 
     expect(
-      await peerNetworking1.messageRouter.offer({
+      await peerNetworking1.messageRouter.offer(Context.default(), {
         topic,
         author: peerNetworking1.peer,
         recipient: peerNetworking2.peer,
@@ -97,7 +98,7 @@ describe('Signal Integration Test', () => {
     ).toEqual(expect.objectContaining({ accept: true }));
 
     expect(
-      await peerNetworking2.messageRouter.offer({
+      await peerNetworking2.messageRouter.offer(Context.default(), {
         topic,
         author: peerNetworking2.peer,
         recipient: peerNetworking1.peer,
@@ -119,7 +120,7 @@ describe('Signal Integration Test', () => {
           signalBatch: undefined,
         },
       };
-      await peerNetworking1.messageRouter.signal(message);
+      await peerNetworking1.messageRouter.signal(Context.default(), message);
 
       await expect.poll(() => peerNetworking2.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }
@@ -135,7 +136,7 @@ describe('Signal Integration Test', () => {
           signalBatch: undefined,
         },
       };
-      await peerNetworking2.messageRouter.signal(message);
+      await peerNetworking2.messageRouter.signal(Context.default(), message);
 
       await expect.poll(() => peerNetworking1.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }

package/src/signal/signal-connection.ts

@@ -2,6 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
+import { type Context } from '@dxos/context';
 import { type PublicKey } from '@dxos/keys';
 import { type PeerInfo } from '@dxos/messaging';
 
@@ -12,10 +13,10 @@ export interface SignalConnection {
   /**
    * Join topic on signal network, to be discoverable by other peers.
    */
-  join(params: { topic: PublicKey; peer: PeerInfo }): Promise<void>;
+  join(ctx: Context, params: { topic: PublicKey; peer: PeerInfo }): Promise<void>;
 
   /**
    * Leave topic on signal network, to stop being discoverable by other peers.
    */
-  leave(params: { topic: PublicKey; peer: PeerInfo }): Promise<void>;
+  leave(ctx: Context, params: { topic: PublicKey; peer: PeerInfo }): Promise<void>;
 }

package/src/signal/signal-messenger.ts

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+import { Context } from '@dxos/context';
 import { type PublicKey } from '@dxos/keys';
 import { type PeerInfo } from '@dxos/messaging';
 import { type Answer, type Offer, type Signal, type SignalBatch } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -29,10 +30,10 @@ export interface SignalMessenger {
   /**
    * Offer/answer RPC.
    */
-  offer(msg: OfferMessage): Promise<Answer>;
+  offer(ctx: Context, msg: OfferMessage): Promise<Answer>;
 
   /**
    * Reliably send a signal to a peer.
    */
-  signal(msg: SignalMessage): Promise<void>;
+  signal(ctx: Context, msg: SignalMessage): Promise<void>;
 }

package/src/signal/swarm-messenger.node.test.ts

@@ -5,6 +5,7 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { type Awaited } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
@@ -37,8 +38,8 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
     topic,
   }: {
     signalApiUrl: string;
-    onSignal?: (msg: SignalMessage) => Promise<void>;
-    onOffer?: (msg: OfferMessage) => Promise<Answer>;
+    onSignal?: (ctx: Context, msg: SignalMessage) => Promise<void>;
+    onOffer?: (ctx: Context, msg: OfferMessage) => Promise<Answer>;
     topic: PublicKey;
   }) => {
     const peer = { peerKey: PublicKey.random().toHex() };
@@ -52,12 +53,12 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
     await messenger.listen({
       peer,
       payloadType: 'dxos.mesh.swarm.SwarmMessage',
-      onMessage: async (message) => await router.receiveMessage(message),
+      onMessage: async (message) => await router.receiveMessage(Context.default(), message),
     });
 
     const router: SwarmMessenger = new SwarmMessenger({
       // todo(mykola): added catch to avoid not finished request.
-      sendMessage: async (message) => await messenger.sendMessage(message),
+      sendMessage: async (ctx, message) => await messenger.sendMessage(ctx, message),
       onSignal,
       onOffer,
       topic,
@@ -72,7 +73,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
 
   test('signaling between 2 clients', async () => {
     const received: SignalMessage[] = [];
-    const signalMock1 = async (msg: SignalMessage) => {
+    const signalMock1 = async (_ctx: Context, msg: SignalMessage) => {
       received.push(msg);
     };
     const { signalManager: signalManager1, peer: peer1 } = await createSignalClientAndMessageRouter({
@@ -89,8 +90,8 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
 
-    await signalManager1.join({ topic, peer: peer1 });
-    await signalManager2.join({ topic, peer: peer2 });
+    await signalManager1.join(Context.default(), { topic, peer: peer1 });
+    await signalManager2.join(Context.default(), { topic, peer: peer2 });
 
     const msg: SignalMessage = {
       author: peer2,
@@ -102,7 +103,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
         signalBatch: undefined,
       },
     };
-    await router2.signal(msg);
+    await router2.signal(Context.default(), msg);
 
     await expect.poll(() => received[0]).toEqual(expect.objectContaining(msg));
   });
@@ -125,9 +126,9 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
 
-    await signalManager1.join({ topic, peer: peer1 });
-    await signalManager2.join({ topic, peer: peer2 });
-    const answer = await router1.offer({
+    await signalManager1.join(Context.default(), { topic, peer: peer1 });
+    await signalManager2.join(Context.default(), { topic, peer: peer2 });
+    const answer = await router1.offer(Context.default(), {
       author: peer1,
       recipient: peer2,
       sessionId: PublicKey.random(),
@@ -139,7 +140,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
 
   test('signaling between 3 clients', async () => {
     const received1: SignalMessage[] = [];
-    const signalMock1 = async (msg: SignalMessage) => {
+    const signalMock1 = async (_ctx: Context, msg: SignalMessage) => {
       received1.push(msg);
     };
     const {
@@ -153,7 +154,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
     const received2: SignalMessage[] = [];
-    const signalMock2 = async (msg: SignalMessage) => {
+    const signalMock2 = async (_ctx: Context, msg: SignalMessage) => {
       received2.push(msg);
     };
     const {
@@ -167,7 +168,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
     const received3: SignalMessage[] = [];
-    const signalMock3 = async (msg: SignalMessage) => {
+    const signalMock3 = async (_ctx: Context, msg: SignalMessage) => {
       received3.push(msg);
     };
     const {
@@ -181,9 +182,9 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
 
-    await signalManager1.join({ topic, peer: peer1 });
-    await signalManager2.join({ topic, peer: peer2 });
-    await signalManager3.join({ topic, peer: peer3 });
+    await signalManager1.join(Context.default(), { topic, peer: peer1 });
+    await signalManager2.join(Context.default(), { topic, peer: peer2 });
+    await signalManager3.join(Context.default(), { topic, peer: peer3 });
 
     // sending signal from peer1 to peer3.
     const msg1to3: SignalMessage = {
@@ -193,7 +194,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
       data: { signal: { payload: { msg: '1to3' } }, signalBatch: undefined },
     };
-    await router1.signal(msg1to3);
+    await router1.signal(Context.default(), msg1to3);
     await expect.poll(() => received3[0]).toEqual(expect.objectContaining(msg1to3));
 
     // sending signal from peer2 to peer3.
@@ -204,7 +205,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
       data: { signal: { payload: { msg: '2to3' } }, signalBatch: undefined },
     };
-    await router2.signal(msg2to3);
+    await router2.signal(Context.default(), msg2to3);
     await expect.poll(() => received3[1]).toEqual(expect.objectContaining(msg2to3));
 
     // sending signal from peer3 to peer1.
@@ -215,7 +216,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
       data: { signal: { payload: { msg: '3to1' } }, signalBatch: undefined },
     };
-    await router3.signal(msg3to1);
+    await router3.signal(Context.default(), msg3to1);
     await expect.poll(() => received1[0]).toEqual(expect.objectContaining(msg3to1));
   });
 
@@ -241,11 +242,11 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
       topic,
     });
 
-    await signalManager1.join({ topic, peer: peer1 });
-    await signalManager2.join({ topic, peer: peer2 });
+    await signalManager1.join(Context.default(), { topic, peer: peer1 });
+    await signalManager2.join(Context.default(), { topic, peer: peer2 });
 
     // sending offer from peer1 to peer2.
-    const answer1 = await router1.offer({
+    const answer1 = await router1.offer(Context.default(), {
       author: peer1,
       recipient: peer2,
       sessionId: PublicKey.random(),
@@ -255,7 +256,7 @@ describe('SwarmMessenger', { timeout: 7000 }, () => {
     expect(answer1.accept).toEqual(true);
 
     // sending offer from peer2 to peer1.
-    const answer2 = await router2.offer({
+    const answer2 = await router2.offer(Context.default(), {
       author: peer2,
       recipient: peer1,
       sessionId: PublicKey.random(),

package/src/signal/swarm-messenger.ts

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

@@ -44,9 +44,9 @@ describe.skip('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({
@@ -66,9 +66,9 @@ describe.skip('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({