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

package/src/network-manager.ts

@@ -12,7 +12,9 @@ import { PublicKey } from '@dxos/protocols';
 import { ComplexMap } from '@dxos/util';
 
 import { ConnectionLog } from './connection-log';
-import { InMemorySignalManager, SignalManager, SignalApi, WebsocketSignalManager } from './signal';
+import { Message } from './proto/gen/dxos/mesh/signal';
+import { InMemorySignalManager, SignalManager, WebsocketSignalManager } from './signal';
+import { MessageRouter } from './signal/message-router';
 import { Swarm, SwarmMapper } from './swarm';
 import { Topology } from './topology';
 import { createWebRTCTransportFactory, inMemoryTransportFactory } from './transport';
@@ -38,6 +40,7 @@ export class NetworkManager {
   private readonly _swarms = new ComplexMap<PublicKey, Swarm>(key => key.toHex());
   private readonly _maps = new ComplexMap<PublicKey, SwarmMapper>(key => key.toHex());
   private readonly _signalManager: SignalManager;
+  private readonly _messageRouter: MessageRouter;
   private readonly _connectionLog?: ConnectionLog;
 
   public readonly topicsUpdated = new Event<void>();
@@ -45,8 +48,8 @@ export class NetworkManager {
   constructor (options: NetworkManagerOptions = {}) {
     this._ice = options.ice ?? [];
 
-    const onOffer = async (message: SignalApi.SignalMessage) =>
-      await this._swarms.get(message.topic)?.onOffer(message) ?? { accept: false };
+    const onOffer = async (message: Message) =>
+      await this._swarms.get(message.topic!)?.onOffer(message) ?? { accept: false };
 
     this._signalManager = options.signal
       ? new WebsocketSignalManager(options.signal, onOffer)
@@ -54,8 +57,14 @@ export class NetworkManager {
 
     this._signalManager.peerCandidatesChanged
       .on(([topic, candidates]) => this._swarms.get(topic)?.onPeerCandidatesChanged(candidates));
-    this._signalManager.onSignal
-      .on(msg => this._swarms.get(msg.topic)?.onSignal(msg));
+
+    this._signalManager.onSignal.on(msg => this._messageRouter.receiveMessage(msg));
+
+    this._messageRouter = new MessageRouter({
+      sendMessage: msg => this._signalManager.signal(msg),
+      onSignal: async (msg) => this._swarms.get(msg.topic!)?.onSignal(msg),
+      onOffer: msg => onOffer(msg)
+    });
 
     if (options.log) {
       this._connectionLog = new ConnectionLog();
@@ -108,7 +117,8 @@ export class NetworkManager {
       peerId,
       topology,
       protocol,
-      this._signalManager,
+      this._messageRouter,
+      this._signalManager.lookup.bind(this._signalManager),
       transportFactory,
       options.label
     );

package/src/proto/defs/dxos/mesh/signal.proto

@@ -0,0 +1,38 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+syntax = "proto3";
+
+import "@dxos/protocols/src/proto/dxos/halo/keys.proto";
+
+package dxos.mesh.signal;
+
+message Message {
+  /// Sender's public key.
+  PubKey id = 1;
+  /// Receiver`s public key.
+  PubKey remoteId = 2;
+  PubKey topic = 3;
+  PubKey sessionId = 4;
+  MessageData data = 5;
+}
+
+message MessageData {
+  oneof payload {
+    Offer offer = 1;
+    Answer answer = 2;
+    Signal signal = 3;
+  }
+}
+
+message Offer {
+}
+
+message Answer {
+  bool accept = 1;
+}
+
+message Signal {
+  string json = 1;
+}

package/src/proto/gen/dxos/credentials.ts

@@ -0,0 +1,27 @@
+import type { Stream } from "@dxos/codec-protobuf";
+import substitutions from "../../substitutions";
+import * as dxos_halo_keys from "./halo/keys";
+import * as dxos_mesh_signal from "./mesh/signal";
+import * as google_protobuf from "../google/protobuf";
+export interface Message {
+    payload: google_protobuf.Any;
+}
+/**
+ * A generic container message used whenever messages are signed (e.g. PartyCredential)
+ */
+export interface SignedMessage {
+    signed: SignedMessage.Signed;
+    signatures?: SignedMessage.Signature[];
+}
+export namespace SignedMessage {
+    export interface Signed {
+        created: string;
+        nonce: Uint8Array;
+        payload: google_protobuf.Any;
+    }
+    export interface Signature {
+        key: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+        signature: Uint8Array;
+        keyChain?: dxos_halo_keys.KeyChain;
+    }
+}

package/src/proto/gen/dxos/halo/keys.ts

@@ -0,0 +1,62 @@
+import type { Stream } from "@dxos/codec-protobuf";
+import substitutions from "../../../substitutions";
+import * as dxos_credentials from "../credentials";
+import * as dxos_mesh_signal from "../mesh/signal";
+import * as google_protobuf from "../../google/protobuf";
+export enum KeyType {
+    UNKNOWN = 0,
+    IDENTITY = 1,
+    DEVICE = 2,
+    PARTY = 3,
+    FEED = 4,
+    DXNS_ADDRESS = 5
+}
+export interface PubKey {
+    data?: Uint8Array;
+}
+export interface PrivKey {
+    data?: Uint8Array;
+}
+export interface KeyRecord {
+    /**
+     * The `KeyType` type of the key. This is often unknown for keys from other sources.
+     */
+    type: KeyType;
+    /**
+     * The public key as a Buffer (required).
+     */
+    publicKey: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    /**
+     * The secret key as a Buffer (this will never be visible outside the Keyring).
+     */
+    secretKey?: ReturnType<(typeof substitutions)["dxos.halo.keys.PrivKey"]["decode"]>;
+    /**
+     * Is this key from a Greeting "hint"?
+     */
+    hint?: boolean;
+    /**
+     * Determines if this is our key?
+     * Usually true if `secretKey` is present; may be false for "inception keys" such as the Party key.
+     */
+    own?: boolean;
+    /**
+     * Is this key to be trusted?
+     */
+    trusted?: boolean;
+    /**
+     * An RFC-3339 date/time string for when the key was added to the Keyring.
+     */
+    added?: string;
+    /**
+     * An RFC-3339 date/time string for when the key was created.
+     */
+    created?: string;
+}
+export interface KeyRecordList {
+    keys?: KeyRecord[];
+}
+export interface KeyChain {
+    publicKey: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    message: dxos_credentials.SignedMessage;
+    parents?: KeyChain[];
+}

package/src/proto/gen/dxos/mesh/signal.ts

@@ -0,0 +1,31 @@
+import type { Stream } from "@dxos/codec-protobuf";
+import substitutions from "../../../substitutions";
+import * as dxos_credentials from "../credentials";
+import * as dxos_halo_keys from "../halo/keys";
+import * as google_protobuf from "../../google/protobuf";
+export interface Message {
+    /**
+     * Sender's public key.
+     */
+    id?: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    /**
+     * Receiver`s public key.
+     */
+    remoteId?: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    topic?: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    sessionId?: ReturnType<(typeof substitutions)["dxos.halo.keys.PubKey"]["decode"]>;
+    data?: MessageData;
+}
+export interface MessageData {
+    offer?: Offer;
+    answer?: Answer;
+    signal?: Signal;
+}
+export interface Offer {
+}
+export interface Answer {
+    accept?: boolean;
+}
+export interface Signal {
+    json?: string;
+}

package/src/proto/gen/google/protobuf.ts

@@ -0,0 +1,9 @@
+import type { Stream } from "@dxos/codec-protobuf";
+import substitutions from "../../substitutions";
+import * as dxos_credentials from "../dxos/credentials";
+import * as dxos_halo_keys from "../dxos/halo/keys";
+import * as dxos_mesh_signal from "../dxos/mesh/signal";
+export interface Any {
+    type_url?: string;
+    value?: Uint8Array;
+}

package/src/proto/gen/index.ts

@@ -0,0 +1,28 @@
+import { Schema } from "@dxos/codec-protobuf";
+import * as dxos_credentials from "./dxos/credentials";
+import * as dxos_halo_keys from "./dxos/halo/keys";
+import * as dxos_mesh_signal from "./dxos/mesh/signal";
+import * as google_protobuf from "./google/protobuf";
+import substitutions from "../substitutions";
+export interface TYPES {
+    "dxos.credentials.Message": dxos_credentials.Message;
+    "dxos.credentials.SignedMessage": dxos_credentials.SignedMessage;
+    "dxos.credentials.SignedMessage.Signature": dxos_credentials.SignedMessage.Signature;
+    "dxos.credentials.SignedMessage.Signed": dxos_credentials.SignedMessage.Signed;
+    "dxos.halo.keys.KeyChain": dxos_halo_keys.KeyChain;
+    "dxos.halo.keys.KeyRecord": dxos_halo_keys.KeyRecord;
+    "dxos.halo.keys.KeyRecordList": dxos_halo_keys.KeyRecordList;
+    "dxos.halo.keys.KeyType": dxos_halo_keys.KeyType;
+    "dxos.halo.keys.PrivKey": dxos_halo_keys.PrivKey;
+    "dxos.halo.keys.PubKey": dxos_halo_keys.PubKey;
+    "dxos.mesh.signal.Answer": dxos_mesh_signal.Answer;
+    "dxos.mesh.signal.Message": dxos_mesh_signal.Message;
+    "dxos.mesh.signal.MessageData": dxos_mesh_signal.MessageData;
+    "dxos.mesh.signal.Offer": dxos_mesh_signal.Offer;
+    "dxos.mesh.signal.Signal": dxos_mesh_signal.Signal;
+    "google.protobuf.Any": google_protobuf.Any;
+}
+export interface SERVICES {
+}
+export const schemaJson = JSON.parse("{\"nested\":{\"dxos\":{\"nested\":{\"credentials\":{\"nested\":{\"Message\":{\"fields\":{\"payload\":{\"rule\":\"required\",\"type\":\"google.protobuf.Any\",\"id\":1,\"comment\":null}},\"comment\":null},\"SignedMessage\":{\"fields\":{\"signed\":{\"rule\":\"required\",\"type\":\"Signed\",\"id\":1,\"comment\":null},\"signatures\":{\"rule\":\"repeated\",\"type\":\"Signature\",\"id\":2,\"comment\":null}},\"nested\":{\"Signature\":{\"fields\":{\"key\":{\"rule\":\"required\",\"type\":\"PubKey\",\"id\":1,\"comment\":null},\"signature\":{\"rule\":\"required\",\"type\":\"bytes\",\"id\":2,\"comment\":null},\"keyChain\":{\"type\":\"KeyChain\",\"id\":3,\"comment\":null}},\"comment\":null},\"Signed\":{\"fields\":{\"created\":{\"rule\":\"required\",\"type\":\"string\",\"id\":1,\"comment\":null},\"nonce\":{\"rule\":\"required\",\"type\":\"bytes\",\"id\":2,\"comment\":null},\"payload\":{\"rule\":\"required\",\"type\":\"google.protobuf.Any\",\"id\":10,\"comment\":null}},\"comment\":null}},\"comment\":\"A generic container message used whenever messages are signed (e.g. PartyCredential)\"}}},\"halo\":{\"nested\":{\"keys\":{\"nested\":{\"KeyChain\":{\"fields\":{\"publicKey\":{\"rule\":\"required\",\"type\":\"PubKey\",\"id\":1,\"comment\":null},\"message\":{\"rule\":\"required\",\"type\":\"SignedMessage\",\"id\":2,\"comment\":null},\"parents\":{\"rule\":\"repeated\",\"type\":\"KeyChain\",\"id\":3,\"comment\":null}},\"comment\":null},\"KeyRecord\":{\"fields\":{\"type\":{\"rule\":\"required\",\"type\":\"KeyType\",\"id\":1,\"comment\":\"The `KeyType` type of the key. This is often unknown for keys from other sources.\"},\"publicKey\":{\"rule\":\"required\",\"type\":\"PubKey\",\"id\":2,\"comment\":\"The public key as a Buffer (required).\"},\"secretKey\":{\"type\":\"PrivKey\",\"id\":3,\"comment\":\"The secret key as a Buffer (this will never be visible outside the Keyring).\"},\"hint\":{\"type\":\"bool\",\"id\":4,\"comment\":\"Is this key from a Greeting \\\"hint\\\"?\"},\"own\":{\"type\":\"bool\",\"id\":5,\"comment\":\"Determines if this is our key?\\nUsually true if `secretKey` is present; may be false for \\\"inception keys\\\" such as the Party key.\"},\"trusted\":{\"type\":\"bool\",\"id\":6,\"comment\":\"Is this key to be trusted?\"},\"added\":{\"type\":\"string\",\"id\":7,\"comment\":\"An RFC-3339 date/time string for when the key was added to the Keyring.\"},\"created\":{\"type\":\"string\",\"id\":8,\"comment\":\"An RFC-3339 date/time string for when the key was created.\"}},\"comment\":null},\"KeyRecordList\":{\"fields\":{\"keys\":{\"rule\":\"repeated\",\"type\":\"KeyRecord\",\"id\":1,\"comment\":null}},\"comment\":null},\"KeyType\":{\"values\":{\"UNKNOWN\":0,\"IDENTITY\":1,\"DEVICE\":2,\"PARTY\":3,\"FEED\":4,\"DXNS_ADDRESS\":5},\"comment\":null,\"comments\":{\"UNKNOWN\":null,\"IDENTITY\":null,\"DEVICE\":null,\"PARTY\":null,\"FEED\":null,\"DXNS_ADDRESS\":null}},\"PrivKey\":{\"fields\":{\"data\":{\"type\":\"bytes\",\"id\":1,\"comment\":null}},\"comment\":null},\"PubKey\":{\"fields\":{\"data\":{\"type\":\"bytes\",\"id\":1,\"comment\":null}},\"comment\":null}}}}},\"mesh\":{\"nested\":{\"signal\":{\"nested\":{\"Answer\":{\"fields\":{\"accept\":{\"type\":\"bool\",\"id\":1,\"comment\":null}},\"comment\":null},\"Message\":{\"fields\":{\"id\":{\"type\":\"PubKey\",\"id\":1,\"comment\":\"Sender's public key.\"},\"remoteId\":{\"type\":\"PubKey\",\"id\":2,\"comment\":\"Receiver`s public key.\"},\"topic\":{\"type\":\"PubKey\",\"id\":3,\"comment\":null},\"sessionId\":{\"type\":\"PubKey\",\"id\":4,\"comment\":null},\"data\":{\"type\":\"MessageData\",\"id\":5,\"comment\":null}},\"comment\":null},\"MessageData\":{\"oneofs\":{\"payload\":{\"oneof\":[\"offer\",\"answer\",\"signal\"],\"comment\":null}},\"fields\":{\"offer\":{\"type\":\"Offer\",\"id\":1,\"comment\":null},\"answer\":{\"type\":\"Answer\",\"id\":2,\"comment\":null},\"signal\":{\"type\":\"Signal\",\"id\":3,\"comment\":null}},\"comment\":null},\"Offer\":{\"fields\":{},\"comment\":null},\"Signal\":{\"fields\":{\"json\":{\"type\":\"string\",\"id\":1,\"comment\":null}},\"comment\":null}}}}}}},\"google\":{\"nested\":{\"protobuf\":{\"nested\":{\"Any\":{\"fields\":{\"type_url\":{\"type\":\"string\",\"id\":1},\"value\":{\"type\":\"bytes\",\"id\":2}},\"comment\":null}}}}}}}");
+export const schema = Schema.fromJson<TYPES, SERVICES>(schemaJson, substitutions);

package/src/proto/substitutions.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import { publicKeySubstitutions } from '@dxos/protocols';
+
+export default {
+  ...publicKeySubstitutions
+};

package/src/signal/in-memory-signal-manager.ts

@@ -8,6 +8,7 @@ import { Event } from '@dxos/async';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, ComplexSet } from '@dxos/util';
 
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
 import { SignalApi } from './signal-api';
 import { SignalManager } from './signal-manager';
 
@@ -15,10 +16,10 @@ export class InMemorySignalManager 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 _onOffer: (message: SignalApi.SignalMessage) => Promise<SignalApi.Answer>
+    private readonly _onOffer: (message: Message) => Promise<Answer>
   ) {}
 
   getStatus (): SignalApi.Status[] {
@@ -48,12 +49,14 @@ export class InMemorySignalManager implements SignalManager {
     setTimeout(() => this.peerCandidatesChanged.emit([topic, Array.from(state.swarms.get(topic)!.values())]), 0);
   }
 
-  offer (msg: SignalApi.SignalMessage) {
+  offer (msg: Message) {
+    assert(msg.remoteId);
     assert(state.connections.has(msg.remoteId), 'Peer not connected');
     return state.connections.get(msg.remoteId)!._onOffer(msg);
   }
 
-  async signal (msg: SignalApi.SignalMessage) {
+  async signal (msg: Message) {
+    assert(msg.remoteId);
     assert(state.connections.get(msg.remoteId), 'Peer not connected');
     state.connections.get(msg.remoteId)!.onSignal.emit(msg);
   }

package/src/signal/message-router.test.ts

@@ -0,0 +1,218 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { expect, mockFn } from 'earljs';
+import { it as test, describe } from 'mocha';
+import waitForExpect from 'wait-for-expect';
+
+import { Awaited } from '@dxos/async';
+import { PublicKey } from '@dxos/protocols';
+import { createTestBroker } from '@dxos/signal';
+import { afterTest } from '@dxos/testutils';
+import { randomInt } from '@dxos/util';
+
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { MessageRouter } from './message-router';
+import { SignalClient } from './signal-client';
+
+describe('MessageRouter', () => {
+  let topic: PublicKey;
+  let peer1: PublicKey;
+  let peer2: PublicKey;
+
+  let broker1: Awaited<ReturnType<typeof createTestBroker>>;
+  const signalApiPort1 = randomInt(10000, 50000);
+  const signalApiUrl1 = 'http://0.0.0.0:' + signalApiPort1;
+
+  before(async () => {
+    broker1 = await createTestBroker(signalApiPort1);
+  });
+
+  beforeEach(() => {
+    topic = PublicKey.random();
+    peer1 = PublicKey.random();
+    peer2 = PublicKey.random();
+  });
+
+  after(async function () {
+    this.timeout(0);
+    await broker1.stop();
+  });
+
+  const createSignalClientAndMessageRouter = async (
+    signalApiUrl: string,
+    onSignal: (msg: Message) => Promise<void> = (async () => {}) as any,
+    onOffer: (msg: Message) => Promise<Answer> = async () => ({ accept: true })
+  ) => {
+
+    // eslint-disable-next-line prefer-const
+    let api: SignalClient;
+    const router: MessageRouter = new MessageRouter({
+      // todo(mykola): added catch to avoid not finished request.
+      sendMessage: (msg: Message) => api.signal(msg).catch((_) => { }),
+      onSignal: onSignal,
+      onOffer: onOffer
+    });
+
+    api = new SignalClient(
+      signalApiUrl,
+      (async () => {}) as any,
+      async (msg: Message) => router.receiveMessage(msg)
+    );
+
+    afterTest(() => api.close());
+    return {
+      api,
+      router
+    };
+  };
+
+  test('signaling between 2 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api1 } = await createSignalClientAndMessageRouter(signalApiUrl1, signalMock1);
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(signalApiUrl1);
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const msg: Message = {
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '{"asd": "asd"}' } }
+    };
+    await router2.signal(msg);
+
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg]);
+    }, 4_000);
+  }).timeout(5_000);
+
+  test('offer/answer', async () => {
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      (async () => {}) as any,
+      async () => ({ accept: true })
+    );
+    const { api: api2 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      (async () => {}) as any,
+      async () => ({ accept: true })
+    );
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    const answer = await router1.offer({
+      id: peer1,
+      remoteId: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: { } }
+    });
+    expect(answer).toEqual({ accept: true });
+  }).timeout(5_000);
+
+  test('signaling between 3 clients', async () => {
+    const signalMock1 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      signalMock1,
+      async () => ({ accept: true })
+    );
+    const signalMock2 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      signalMock2,
+      async () => ({ accept: true })
+    );
+    const signalMock3 = mockFn<(msg: Message) => Promise<void>>().resolvesTo();
+    const { api: api3, router: router3 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      signalMock3,
+      async () => ({ accept: true })
+    );
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+    const peer3 = PublicKey.random();
+    await api3.join(topic, peer3);
+
+    // sending signal from peer1 to peer3.
+    const msg1to3: Message = {
+      id: peer1,
+      remoteId: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '1to3' } }
+    };
+    await router1.signal(msg1to3);
+    await waitForExpect(() => {
+      expect(signalMock3).toHaveBeenCalledWith([msg1to3]);
+    }, 4_000);
+
+    // sending signal from peer2 to peer3.
+    const msg2to3: Message = {
+      id: peer2,
+      remoteId: peer3,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '2to3' } }
+    };
+    await router2.signal(msg2to3);
+    await waitForExpect(() => {
+      expect(signalMock3).toHaveBeenCalledWith([msg2to3]);
+    }, 4_000);
+
+    // sending signal from peer3 to peer1.
+    const msg3to1: Message = {
+      id: peer3,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { signal: { json: '3to1' } }
+    };
+    await router3.signal(msg3to1);
+    await waitForExpect(() => {
+      expect(signalMock1).toHaveBeenCalledWith([msg3to1]);
+    }, 4_000);
+  }).timeout(5_000);
+
+  test('two offers', async () => {
+    const { api: api1, router: router1 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      (async () => {}) as any,
+      async () => ({ accept: true })
+    );
+    const { api: api2, router: router2 } = await createSignalClientAndMessageRouter(
+      signalApiUrl1,
+      (async () => {}) as any,
+      async () => ({ accept: true })
+    );
+
+    await api1.join(topic, peer1);
+    await api2.join(topic, peer2);
+
+    // sending offer from peer1 to peer2.
+    const answer1 = await router1.offer({
+      id: peer1,
+      remoteId: peer2,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer1).toEqual({ accept: true });
+
+    // sending offer from peer2 to peer1.
+    const answer2 = await router2.offer({
+      id: peer2,
+      remoteId: peer1,
+      sessionId: PublicKey.random(),
+      topic,
+      data: { offer: {} }
+    });
+    expect(answer2).toEqual({ accept: true });
+  }).timeout(5_000);
+});

package/src/signal/message-router.ts

@@ -0,0 +1,89 @@
+//
+// Copyright 2020 DXOS.org
+//
+
+import assert from 'assert';
+
+import { PublicKey } from '@dxos/protocols';
+import { ComplexMap } from '@dxos/util';
+
+import { Answer, Message } from '../proto/gen/dxos/mesh/signal';
+import { SignalMessaging } from './signal-manager';
+
+interface OfferRecord {
+  resolve: (answer: Answer) => void;
+  reject: (error?: Error) => void;
+}
+
+interface MessageRouterOptions {
+  onSignal: (message: Message) => Promise<void>;
+  sendMessage: (message: Message) => Promise<void>;
+  onOffer: (message: Message) => Promise<Answer>;
+}
+
+/**
+ * Adds offer/answer RPC and reliable messaging.
+ */
+// TODO(mykola): https://github.com/dxos/protocols/issues/1316
+export class MessageRouter implements SignalMessaging {
+  private readonly _offerRecords: ComplexMap<PublicKey, OfferRecord> = new ComplexMap(key => key.toHex());
+  private readonly _onSignal: (message: Message) => Promise<void>;
+  private readonly _sendMessage: (message: Message) => Promise<void>;
+  private readonly _onOffer: (message: Message) => Promise<Answer>;
+
+  constructor ({
+    sendMessage,
+    onSignal,
+    onOffer
+  }: MessageRouterOptions) {
+    this._sendMessage = sendMessage;
+    this._onSignal = onSignal;
+    this._onOffer = onOffer;
+  }
+
+  async receiveMessage (message: Message): Promise<void> {
+    if (message.data?.offer) {
+      await this._handleOffer(message);
+    } else if (message.data?.answer) {
+      await this._resolveAnswers(message);
+    } else if (message.data?.signal) {
+      await this._onSignal(message);
+    }
+  }
+
+  async signal (message: Message): Promise<void> {
+    assert(message.data?.signal);
+    await this._sendMessage(message);
+  }
+
+  async offer (message: Message): Promise<Answer> {
+    const promise = new Promise<Answer>((resolve, reject) => {
+      assert(message.sessionId);
+      this._offerRecords.set(message.sessionId, { resolve, reject });
+    });
+    await this._sendMessage(message);
+    return promise;
+  }
+
+  private async _resolveAnswers (message: Message): Promise<void> {
+    assert(message.sessionId);
+    const offerRecord = this._offerRecords.get(message.sessionId);
+    if (offerRecord) {
+      this._offerRecords.delete(message.sessionId);
+      assert(message.data?.answer);
+      offerRecord.resolve(message.data.answer);
+    }
+  }
+
+  private async _handleOffer (message: Message): Promise<void> {
+    const answer = await this._onOffer(message);
+    const answerMessage = {
+      id: message.remoteId,
+      remoteId: message.id,
+      topic: message.topic,
+      sessionId: message.sessionId,
+      data: { answer: answer }
+    };
+    await this._sendMessage(answerMessage);
+  }
+}

package/src/signal/signal-api.ts

@@ -47,7 +47,13 @@ export namespace SignalApi {
   }
 
   export type SignalMessage = {
+    /**
+     *  Sender's public key.
+     */
     id: PublicKey
+    /**
+     *  Receiver`s public key.
+     */
     remoteId: PublicKey
     topic: PublicKey
     sessionId: PublicKey