@dxos/network-manager 2.33.8-dev.6bc74570 → 2.33.8

package/src/signal/signal-client.test.ts

@@ -11,7 +11,7 @@ import { PublicKey } from '@dxos/protocols';
 import { createTestBroker } from '@dxos/signal';
 import { randomInt } from '@dxos/util';
 
-import { SignalApi } from './signal-api';
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalClient } from './signal-client';
 
 describe('SignalApi', () => {
@@ -47,6 +47,29 @@ describe('SignalApi', () => {
     // code await broker2.stop();
   });
 
+  test('message between 2 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>()
+      .resolvesTo();
+    api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock1);
+    api2 = new SignalClient(signalApiUrl1, (async () => {}) as any, (async () => {}) as any);
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const msg: Message = {
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: "foo: 'bar'" } }
+    };
+    await api2.signal(msg);
+
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg]);
+    }, 4_000);
+  }).timeout(5_000);
+
   test('join', async () => {
     api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, async () => {});
 
@@ -58,14 +81,14 @@ describe('SignalApi', () => {
   }).timeout(1_000);
 
   test('offer', async () => {
-    const offerMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<SignalApi.Answer>>()
+    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
       .resolvesTo({ accept: true });
     api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
 
     await api1.join(topic, peer1);
 
-    const offer: SignalApi.SignalMessage = {
-      data: { foo: 'bar' } as any,
+    const offer: Message = {
+      data: { offer: {} },
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
@@ -77,18 +100,18 @@ describe('SignalApi', () => {
   }).timeout(5_000);
 
   test('signal', async () => {
-    const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
+    const signalMock = mockFn<(msg: Message) => Promise<void>>()
       .resolvesTo();
     api1 = new SignalClient(signalApiUrl1, (async () => {}) as any, signalMock);
 
     await api1.join(topic, peer1);
 
-    const msg: SignalApi.SignalMessage = {
+    const msg: Message = {
       id: peer2,
       remoteId: peer1,
       sessionId: PublicKey.random(),
       topic,
-      data: { foo: 'bar' } as any
+      data: { signal: { json: 'bar' } }
     };
     await api1.signal(msg);
 
@@ -118,9 +141,9 @@ describe('SignalApi', () => {
 
   // Skip because communication between signal servers is not yet implemented.
   test.skip('newly joined peer can receive signals from other signal servers', async () => {
-    const offerMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<SignalApi.Answer>>()
+    const offerMock = mockFn<(msg: Message) => Promise<Answer>>()
       .resolvesTo({ accept: true });
-    const signalMock = mockFn<(msg: SignalApi.SignalMessage) => Promise<void>>()
+    const signalMock = mockFn<(msg: Message) => Promise<void>>()
       .resolvesTo();
 
     api1 = new SignalClient(signalApiUrl1, offerMock, async () => {});
@@ -136,16 +159,16 @@ describe('SignalApi', () => {
       id: peer2,
       topic,
       sessionId,
-      data: {}
+      data: { offer: {} }
     });
     expect(answer).toEqual({ accept: true });
 
-    const msg: SignalApi.SignalMessage = {
+    const msg: Message = {
       id: peer2,
       remoteId: peer1,
       sessionId,
       topic,
-      data: { foo: 'bar' } as any
+      data: { offer: { json: 'bar' } }
     };
     await api1.signal(msg);
 

package/src/signal/signal-client.ts

@@ -7,6 +7,7 @@ import debug from 'debug';
 import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalApi } from './signal-api';
 import { WebsocketRpc } from './websocket-rpc';
 
@@ -53,8 +54,8 @@ export class SignalClient {
    */
   constructor (
     private readonly _host: string,
-    private readonly _onOffer: (message: SignalApi.SignalMessage) => Promise<SignalApi.Answer>,
-    private readonly _onSignal: (message: SignalApi.SignalMessage) => Promise<void>
+    private readonly _onOffer: (message: Message) => Promise<Answer>,
+    private readonly _onSignal: (message: Message) => Promise<void>
   ) {
     this._setState(SignalApi.State.CONNECTING);
     this._createClient();
@@ -89,11 +90,11 @@ export class SignalClient {
       data: message.data
     }));
 
-    this._client.subscribe('signal', (msg: SignalApi.SignalMessage) => this._onSignal({
-      id: PublicKey.from(msg.id),
-      remoteId: PublicKey.from(msg.remoteId),
-      topic: PublicKey.from(msg.topic),
-      sessionId: PublicKey.from(msg.sessionId),
+    this._client.subscribe('signal', (msg: Message) => this._onSignal({
+      id: PublicKey.from(msg.id!),
+      remoteId: PublicKey.from(msg.remoteId!),
+      topic: PublicKey.from(msg.topic!),
+      sessionId: PublicKey.from(msg.sessionId!),
       data: msg.data
     }));
 
@@ -210,25 +211,25 @@ export class SignalClient {
    * Routes an offer to the other peer's _onOffer callback.
    * @returns Other peer's _onOffer callback return value.
    */
-  async offer (payload: SignalApi.SignalMessage): Promise<SignalApi.Answer> {
+  async offer (msg: Message): Promise<Answer> {
     return this._client.call('offer', {
-      id: payload.id.asBuffer(),
-      remoteId: payload.remoteId.asBuffer(),
-      topic: payload.topic.asBuffer(),
-      sessionId: payload.sessionId.asBuffer(),
-      data: payload.data
+      id: msg.id?.asBuffer(),
+      remoteId: msg.remoteId?.asBuffer(),
+      topic: msg.topic?.asBuffer(),
+      sessionId: msg.sessionId?.asBuffer(),
+      data: msg.data
     });
   }
 
   /**
    * Routes an offer to the other peer's _onSignal callback.
    */
-  async signal (payload: SignalApi.SignalMessage): Promise<void> {
+  async signal (payload: Message): Promise<void> {
     return this._client.emit('signal', {
-      id: payload.id.asBuffer(),
-      remoteId: payload.remoteId.asBuffer(),
-      topic: payload.topic.asBuffer(),
-      sessionId: payload.sessionId.asBuffer(),
+      id: payload.id?.asBuffer(),
+      remoteId: payload.remoteId?.asBuffer(),
+      topic: payload.topic?.asBuffer(),
+      sessionId: payload.sessionId?.asBuffer(),
       data: payload.data
     });
   }

package/src/signal/signal-manager.ts

@@ -5,9 +5,12 @@
 import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalApi } from './signal-api';
 
-// TODO(burdon): Document methods.
+/**
+ * Signal peer discovery interface.
+ */
 export interface SignalConnection {
   /**
    * Find peers (triggers async event).
@@ -15,25 +18,37 @@ export interface SignalConnection {
   lookup (topic: PublicKey): void
 
   /**
-   *
+   * Join topic on signal network, to be discoverable by other peers.
    */
-  // TODO(burdon): Document.
-  offer (msg: SignalApi.SignalMessage): Promise<SignalApi.Answer>
+  join (topic: PublicKey, peerId: PublicKey): void
+
+  /**
+   * Leave topic on signal network, to stop being discoverable by other peers.
+   */
+  leave (topic: PublicKey, peerId: PublicKey): void
+}
+
+/**
+ * Signal peer messaging interface.
+ */
+export interface SignalMessaging {
+  /**
+   * Offer/answer RPC.
+   */
+  offer (msg: Message): Promise<Answer>
 
   /**
    * Send message to peer.
    */
-  signal (msg: SignalApi.SignalMessage): Promise<void>
+  signal (msg: Message): Promise<void>
 }
 
-export interface SignalManager extends SignalConnection {
+export interface SignalManager extends SignalConnection, SignalMessaging {
   statusChanged: Event<SignalApi.Status[]>
   commandTrace: Event<SignalApi.CommandTrace>
   peerCandidatesChanged: Event<[topic: PublicKey, candidates: PublicKey[]]>
-  onSignal: Event<SignalApi.SignalMessage>
+  onSignal: Event<Message>
 
   getStatus (): SignalApi.Status[]
-  join (topic: PublicKey, peerId: PublicKey): void
-  leave (topic: PublicKey, peerId: PublicKey): void
   destroy(): Promise<void>
 }

package/src/signal/websocket-signal-manager.ts

@@ -9,6 +9,7 @@ import { Event, synchronized } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap } from '@dxos/util';
 
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalApi } from './signal-api';
 import { SignalClient } from './signal-client';
 import { SignalManager } from './signal-manager';
@@ -27,11 +28,11 @@ export class WebsocketSignalManager implements SignalManager {
   readonly statusChanged = new Event<SignalApi.Status[]>();
   readonly commandTrace = new Event<SignalApi.CommandTrace>();
   readonly peerCandidatesChanged = new Event<[topic: PublicKey, candidates: PublicKey[]]>()
-  readonly onSignal = new Event<SignalApi.SignalMessage>();
+  readonly onSignal = new Event<Message>();
 
   constructor (
     private readonly _hosts: string[],
-    private readonly _onOffer: (message: SignalApi.SignalMessage) => Promise<SignalApi.Answer>
+    private readonly _onOffer: (message: Message) => Promise<Answer>
   ) {
     log(`Created WebsocketSignalManager with signal servers: ${_hosts}`);
     assert(_hosts.length === 1, 'Only a single signaling server connection is supported');
@@ -137,13 +138,13 @@ export class WebsocketSignalManager implements SignalManager {
     }
   }
 
-  offer (msg: SignalApi.SignalMessage) {
+  offer (msg: Message) {
     log(`Offer ${msg.remoteId}`);
     // TODO(marik-d): Broadcast to all signal servers.
     return Array.from(this._servers.values())[0].offer(msg);
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
     log(`Signal ${msg.remoteId}`);
     for (const server of this._servers.values()) {
       void server.signal(msg);

package/src/swarm/connection.ts

@@ -10,7 +10,7 @@ import { ErrorStream } from '@dxos/debug';
 import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 
-import { SignalApi } from '../signal';
+import { Message } from '../proto/gen/dxos/mesh/signal';
 import { Transport, TransportFactory } from '../transport';
 
 const log = debug('dxos:network-manager:swarm:connection');
@@ -51,7 +51,7 @@ export enum ConnectionState {
 export class Connection {
   private _state: ConnectionState = ConnectionState.INITIAL;
   private _transport: Transport | undefined;
-  private _bufferedSignals: SignalApi.SignalMessage[] = [];
+  private _bufferedSignals: Message[] = [];
 
   readonly stateChanged = new Event<ConnectionState>();
   readonly errors = new ErrorStream();
@@ -62,7 +62,7 @@ export class Connection {
     public readonly remoteId: PublicKey,
     public readonly sessionId: PublicKey,
     public readonly initiator: boolean,
-    private readonly _sendSignal: (msg: SignalApi.SignalMessage) => Promise<void>,
+    private readonly _sendSignal: (msg: Message) => Promise<void>,
     private readonly _protocol: Protocol,
     private readonly _transportFactory: TransportFactory
   ) {}
@@ -116,25 +116,27 @@ export class Connection {
     this._bufferedSignals = [];
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
+    assert(msg.sessionId);
     if (!msg.sessionId.equals(this.sessionId)) {
       log('Dropping signal for incorrect session id.');
       return;
     }
-    if (msg.data.type === 'offer' && this._state === ConnectionState.INITIATING_CONNECTION) {
+    assert(msg.data);
+    if (msg.data.offer && this._state === ConnectionState.INITIATING_CONNECTION) {
       throw new Error('Invalid state: Cannot send offer to an initiating peer.');
     }
-    assert(msg.id.equals(this.remoteId));
-    assert(msg.remoteId.equals(this.ownId));
+    assert(msg.id?.equals(this.remoteId));
+    assert(msg.remoteId?.equals(this.ownId));
 
     if (this._state === ConnectionState.INITIAL) {
-      log(`${this.ownId} buffered signal from ${this.remoteId}: ${msg.data.type}`);
+      log(`${this.ownId} buffered signal from ${this.remoteId}: ${msg.data}`);
       this._bufferedSignals.push(msg);
       return;
     }
 
     assert(this._transport, 'Connection not ready to accept signals.');
-    log(`${this.ownId} received signal from ${this.remoteId}: ${msg.data.type}`);
+    log(`${this.ownId} received signal from ${this.remoteId}: ${msg.data}`);
     await this._transport.signal(msg);
   }
 

package/src/swarm/swarm.test.ts

@@ -12,53 +12,75 @@ import { Protocol } from '@dxos/mesh-protocol';
 import { PublicKey } from '@dxos/protocols';
 import { afterTest } from '@dxos/testutils';
 
-import { SignalApi, SignalConnection } from '../signal';
+import { Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessaging } from '../signal';
+import { MessageRouter } from '../signal/message-router';
 import { FullyConnectedTopology } from '../topology';
 import { createWebRTCTransportFactory, WebRTCTransport } from '../transport';
 import { Swarm } from './swarm';
 
 const log = debug('dxos:network-manager:swarm:test');
 
-class MockSignalConnection implements SignalConnection {
+class MockSignalConnection implements SignalMessaging {
   constructor (
     readonly _swarm: () => Swarm,
     readonly _delay = 10
   ) {}
 
-  lookup (topic: PublicKey) {}
-
-  async offer (msg: SignalApi.SignalMessage) {
+  async offer (msg: Message) {
     await sleep(this._delay);
     return this._swarm().onOffer(msg);
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
     await sleep(this._delay);
     await this._swarm().onSignal(msg);
   }
 }
 
-const setup = () => {
+const setup = ({ router = false } = {}) => {
   const topic = PublicKey.random();
   const peerId1 = PublicKey.random();
   const peerId2 = PublicKey.random();
+  // eslint-disable-next-line prefer-const
+  let swarm1: Swarm;
+  // eslint-disable-next-line prefer-const
+  let swarm2: Swarm;
+
+  const mr1: MessageRouter = new MessageRouter({
+    sendMessage: msg => mr2.receiveMessage(msg),
+    onSignal: msg => swarm1.onSignal(msg),
+    onOffer: msg => swarm1.onOffer(msg)
+  });
+
+  const mr2: MessageRouter = new MessageRouter({
+    sendMessage: msg => mr1.receiveMessage(msg),
+    onSignal: msg => swarm2.onSignal(msg),
+    onOffer: msg => swarm2.onOffer(msg)
+  });
 
-  const swarm1: Swarm = new Swarm(
+  const sm1: SignalMessaging = router ? mr1 : new MockSignalConnection(() => swarm2);
+
+  const sm2: SignalMessaging = router ? mr2 : new MockSignalConnection(() => swarm1);
+
+  swarm1 = new Swarm(
     topic,
     peerId1,
     new FullyConnectedTopology(),
     () => new Protocol(),
-    new MockSignalConnection(() => swarm2),
+    sm1,
+    () => {},
     createWebRTCTransportFactory(),
     undefined
   );
 
-  const swarm2: Swarm = new Swarm(
+  swarm2 = new Swarm(
     topic,
     peerId2,
     new FullyConnectedTopology(),
     () => new Protocol(),
-    new MockSignalConnection(() => swarm1),
+    sm2,
+    () => {},
     createWebRTCTransportFactory(),
     undefined
   );
@@ -141,3 +163,31 @@ test('second peer discovered after delay', async () => {
     expect(onData).toHaveBeenCalledWith([data]);
   });
 }).timeout(5_000);
+
+test('swarming with message router', async () => {
+  const { swarm1, swarm2, peerId2 } = setup({ router: true });
+
+  const promise = Promise.all([
+    promiseTimeout(swarm1.connected.waitForCount(1), 3000, new Error('Swarm1 connect timeout.')),
+    promiseTimeout(swarm2.connected.waitForCount(1), 3000, new Error('Swarm2 connect timeout.'))
+  ]);
+
+  swarm1.onPeerCandidatesChanged([peerId2]);
+
+  log('Candidates changed');
+  await promise;
+  log('Swarms connected');
+
+  const swarm1Connection = swarm1.connections[0];
+  const swarm2Connection = swarm2.connections[0];
+  const onData = mockFn<(data: Buffer) => void>().returns(undefined);
+  (swarm2Connection.transport as WebRTCTransport).peer!.on('data', onData);
+
+  const data = Buffer.from('1234');
+  (swarm1Connection.transport as WebRTCTransport).peer!.send(data);
+  await waitForExpect(() => {
+    expect(onData).toHaveBeenCalledWith([data]);
+  });
+  await swarm1.destroy();
+  await swarm2.destroy();
+}).timeout(5_000);

package/src/swarm/swarm.ts

@@ -12,7 +12,8 @@ import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
 import { ProtocolProvider } from '../network-manager';
-import { SignalApi, SignalConnection } from '../signal';
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessaging } from '../signal';
 import { SwarmController, Topology } from '../topology';
 import { TransportFactory } from '../transport';
 import { Topic } from '../types';
@@ -62,7 +63,8 @@ export class Swarm {
     private readonly _ownPeerId: PublicKey,
     private _topology: Topology,
     private readonly _protocolProvider: ProtocolProvider,
-    private readonly _signalConnection: SignalConnection,
+    private readonly _signalMessaging: SignalMessaging,
+    private readonly _lookupPeers: (topic: PublicKey) => void,
     private readonly _transportFactory: TransportFactory,
     private readonly _label: string | undefined
   ) {
@@ -98,12 +100,13 @@ export class Swarm {
     this._topology.update();
   }
 
-  async onOffer (message: SignalApi.SignalMessage): Promise<SignalApi.Answer> {
+  async onOffer (message: Message): Promise<Answer> {
     log(`Offer from ${message.id} topic=${this._topic}`);
     // Id of the peer offering us the connection.
+    assert(message.id);
     const remoteId = message.id;
-    assert(message.remoteId.equals(this._ownPeerId));
-    assert(message.topic.equals(this._topic));
+    assert(message.remoteId?.equals(this._ownPeerId));
+    assert(message.topic?.equals(this._topic));
 
     // Check if we are already trying to connect to that peer.
     if (this._connections.has(remoteId)) {
@@ -123,6 +126,7 @@ export class Swarm {
     let accept = false;
     if (await this._topology.onOffer(remoteId)) {
       if (!this._connections.has(remoteId)) { // Connection might have been already established.
+        assert(message.sessionId);
         const connection = this._createConnection(false, message.id, message.sessionId);
         try {
           connection.connect();
@@ -136,10 +140,11 @@ export class Swarm {
     return { accept };
   }
 
-  async onSignal (message: SignalApi.SignalMessage): Promise<void> {
+  async onSignal (message: Message): Promise<void> {
     log(`Signal ${this._topic} ${JSON.stringify(message)}`);
-    assert(message.remoteId.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.remoteId}`);
-    assert(message.topic.equals(this._topic));
+    assert(message.remoteId?.equals(this._ownPeerId), `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.remoteId}`);
+    assert(message.topic?.equals(this._topic));
+    assert(message.id);
     const connection = this._connections.get(message.id);
     if (!connection) {
       log(`Dropping signal message for non-existent connection: topic=${this._topic}, peerId=${message.id}`);
@@ -183,7 +188,7 @@ export class Swarm {
         this._topology.update();
       },
       lookup: () => {
-        this._signalConnection.lookup(this._topic);
+        this._lookupPeers(this._topic);
       }
     };
   }
@@ -197,12 +202,12 @@ export class Swarm {
     const sessionId = PublicKey.random();
 
     const connection = this._createConnection(true, remoteId, sessionId);
-    this._signalConnection.offer({
+    this._signalMessaging.offer({
       id: this._ownPeerId,
       remoteId,
       sessionId,
       topic: this._topic,
-      data: {}
+      data: { offer: {} }
     })
       .then(answer => {
         log(`Received answer: ${JSON.stringify(answer)} topic=${this._topic} ownId=${this._ownPeerId} remoteId=${remoteId}`);
@@ -240,7 +245,7 @@ export class Swarm {
       remoteId,
       sessionId,
       initiator,
-      (msg: SignalApi.SignalMessage) => this._signalConnection.signal(msg),
+      (msg: Message) => this._signalMessaging.signal(msg),
       this._protocolProvider({ channel: discoveryKey(this._topic), initiator }),
       this._transportFactory
     );

package/src/transport/in-memory-transport.ts

@@ -11,7 +11,7 @@ import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap } from '@dxos/util';
 
-import { SignalApi } from '../signal';
+import { Message } from '../proto/gen/dxos/mesh/signal';
 import { Transport, TransportFactory } from './transport';
 
 const log = debug('dxos:network-manager:swarm:transport:in-memory-transport');
@@ -79,7 +79,7 @@ export class InMemoryTransport implements Transport {
     return this._sessionId;
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
     // No-op.
   }
 

package/src/transport/transport.ts

@@ -6,7 +6,7 @@ import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/protocols';
 
-import { SignalApi } from '../signal';
+import { Message } from '../proto/gen/dxos/mesh/signal';
 
 /**
  * Abstraction over a P2P connection transport. Currently either WebRTC or in-memory.
@@ -15,7 +15,7 @@ export interface Transport {
   closed: Event
   connected: Event
   errors: ErrorStream
-  signal (msg: SignalApi.SignalMessage): Promise<void> // TODO(burdon): Remove async?
+  signal (msg: Message): Promise<void> // TODO(burdon): Remove async?
   close (): Promise<void>
 }
 
@@ -38,7 +38,7 @@ export interface TransportOptions {
   /**
    * Send a signal message to remote peer.
    */
-  sendSignal: (msg: SignalApi.SignalMessage) => Promise<void> // TODO(burdon): Remove async?
+  sendSignal: (msg: Message) => Promise<void> // TODO(burdon): Remove async?
 }
 
 export type TransportFactory = (options: TransportOptions) => Transport

package/src/transport/webrtc-transport.ts

@@ -11,7 +11,7 @@ import { Event } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/protocols';
 
-import { SignalApi } from '../signal';
+import { Message } from '../proto/gen/dxos/mesh/signal';
 import { Transport, TransportFactory } from './transport';
 
 const log = debug('dxos:network-manager:swarm:transport:webrtc');
@@ -35,7 +35,7 @@ export class WebRTCTransport implements Transport {
     private readonly _remoteId: PublicKey,
     private readonly _sessionId: PublicKey,
     private readonly _topic: PublicKey,
-    private readonly _sendSignal: (msg: SignalApi.SignalMessage) => void,
+    private readonly _sendSignal: (msg: Message) => void,
     private readonly _webrtcConfig?: any
   ) {
     log(`Created WebRTC connection ${this._ownId} -> ${this._remoteId} initiator=${this._initiator}`);
@@ -53,7 +53,7 @@ export class WebRTCTransport implements Transport {
           remoteId: this._remoteId,
           sessionId: this._sessionId,
           topic: this._topic,
-          data
+          data: { signal: { json: JSON.stringify(data) } }
         });
       } catch (err: any) {
         this.errors.raise(err);
@@ -89,9 +89,10 @@ export class WebRTCTransport implements Transport {
     return this._peer;
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
     assert(this._peer, 'Connection not ready to accept signals.');
-    this._peer.signal(msg.data);
+    assert(msg.data?.signal?.json, 'Signal message must contain signal data.');
+    this._peer.signal(JSON.parse(msg.data.signal.json));
   }
 
   async close () {