@dxos/network-manager 0.1.17 → 0.1.19

package/src/transport/memory-transport.ts

@@ -8,7 +8,7 @@ import { Transform } from 'node:stream';
 import { Event, Trigger } from '@dxos/async';
 import { ErrorStream } from '@dxos/debug';
 import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap } from '@dxos/util';
 
@@ -45,29 +45,34 @@ export class MemoryTransport implements Transport {
   public readonly connected = new Event<void>();
   public readonly errors = new ErrorStream();
 
-  private readonly _id = PublicKey.random(); // TODO(burdon): Rename peerId? (Use local/remote labels in logs).
+  @logInfo
+  private readonly _instanceId = PublicKey.random(); // TODO(burdon): Rename peerId? (Use local/remote labels in logs).
+
   private readonly _remote = new Trigger<PublicKey>();
 
   private readonly _outgoingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
   private readonly _incomingDelay = createStreamDelay(MEMORY_TRANSPORT_DELAY);
 
   private _destroyed = false;
-  private _remoteId!: PublicKey;
+
+  @logInfo
+  private _remoteInstanceId!: PublicKey;
+
   private _remoteConnection?: MemoryTransport;
 
   constructor(private readonly options: TransportOptions) {
-    log('creating', { id: this._id });
+    log('creating');
 
-    assert(!MemoryTransport._connections.has(this._id), 'Duplicate memory connection');
-    MemoryTransport._connections.set(this._id, this);
+    assert(!MemoryTransport._connections.has(this._instanceId), 'Duplicate memory connection');
+    MemoryTransport._connections.set(this._instanceId, this);
 
     // Initiator will send a signal, the receiver will receive the unique ID and connect the streams.
     if (this.options.initiator) {
       // prettier-ignore
       setTimeout(async () => {
-        log('sending signal', { transportId: this._id });
+        log('sending signal');
         void this.options.sendSignal({
-          payload: { transportId: this._id.toHex() }
+          payload: { transportId: this._instanceId.toHex() }
         });
     });
     } else {
@@ -78,8 +83,8 @@ export class MemoryTransport implements Transport {
             return;
           }
 
-          this._remoteId = remoteId;
-          this._remoteConnection = MemoryTransport._connections.get(this._remoteId);
+          this._remoteInstanceId = remoteId;
+          this._remoteConnection = MemoryTransport._connections.get(this._remoteInstanceId);
           if (!this._remoteConnection) {
             // Remote connection was destroyed before we could connect.
             this._destroyed = true;
@@ -87,11 +92,14 @@ export class MemoryTransport implements Transport {
             return;
           }
 
-          assert(!this._remoteConnection._remoteConnection, new Error(`Remote already connected: ${this._remoteId}`));
+          assert(
+            !this._remoteConnection._remoteConnection,
+            new Error(`Remote already connected: ${this._remoteInstanceId}`)
+          );
           this._remoteConnection._remoteConnection = this;
-          this._remoteConnection._remoteId = this._id;
+          this._remoteConnection._remoteInstanceId = this._instanceId;
 
-          log('connected', { id: this._id, remote: this._remoteId });
+          log('connected');
           this.options.stream
             .pipe(this._outgoingDelay)
             .pipe(this._remoteConnection.options.stream)
@@ -112,14 +120,14 @@ export class MemoryTransport implements Transport {
   }
 
   async destroy(): Promise<void> {
-    log('closing', { id: this._id });
+    log('closing');
     this._destroyed = true;
 
-    MemoryTransport._connections.delete(this._id);
+    MemoryTransport._connections.delete(this._instanceId);
     if (this._remoteConnection) {
-      log('closing', { id: this._remoteId });
+      log('closing');
       this._remoteConnection._destroyed = true;
-      MemoryTransport._connections.delete(this._remoteId);
+      MemoryTransport._connections.delete(this._remoteInstanceId);
 
       // TODO(dmaretskyi): Hypercore streams do not seem to have the unpipe method.
       //  NOTE(burdon): Using readable-stream.wrap() might help (see feed-store).
@@ -135,23 +143,23 @@ export class MemoryTransport implements Transport {
       this._remoteConnection.closed.emit();
       this._remoteConnection._remoteConnection = undefined;
       this._remoteConnection = undefined;
-      log('closed', { id: this._remoteId });
+      log('closed');
     }
 
     this.closed.emit();
-    log('closed', { id: this._id });
+    log('closed');
   }
 
-  signal(signal: Signal) {
-    const { payload: json } = signal;
-    if (json && json.transportId) {
-      // TODO(burdon): Check open?
-      const transportId = json.transportId as string;
-      if (transportId) {
-        const remoteId = PublicKey.fromHex(transportId);
-        log('received signal', { id: this._id, remoteId });
-        this._remote.wake(remoteId);
-      }
+  signal({ payload }: Signal) {
+    log('received signal', { payload });
+    if (!payload?.transportId) {
+      return;
+    }
+    // TODO(burdon): Check open?
+    const transportId = payload.transportId as string;
+    if (transportId) {
+      const remoteId = PublicKey.fromHex(transportId);
+      this._remote.wake(remoteId);
     }
   }
 }

package/src/transport/webrtc-transport-proxy.test.ts

@@ -5,27 +5,21 @@
 // @dxos/test platform=nodejs
 
 import expect from 'expect';
-import { Duplex } from 'stream';
-import waitForExpect from 'wait-for-expect';
 
-import { sleep } from '@dxos/async';
-import { discoveryKey } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
+import { sleep, TestStream } from '@dxos/async';
 import { schema } from '@dxos/protocols';
 import { BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
 import { Signal } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { createLinkedPorts, createProtoRpcPeer, ProtoRpcPeer } from '@dxos/rpc';
-import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
+import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { WebRTCTransportProxy } from './webrtc-transport-proxy';
 import { WebRTCTransportService } from './webrtc-transport-service';
 
 describe('WebRTCTransportProxy', () => {
   const setupProxy = async ({
     initiator = true,
-    stream = new Duplex({ write: () => {}, read: () => {} }),
+    stream = new TestStream(),
     sendSignal = async () => {}
   }: {
     initiator?: boolean;
@@ -99,18 +93,10 @@ describe('WebRTCTransportProxy', () => {
     .retries(3);
 
   test('establish connection and send data through with protocol', async () => {
-    const topic = PublicKey.random();
-    const peer1Id = PublicKey.random();
-    const peer2Id = PublicKey.random();
-
-    const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-    const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+    const stream1 = new TestStream();
     const { webRTCTransportProxy: connection1 } = await setupProxy({
       initiator: true,
-      stream: protocolProvider1({
-        channel: discoveryKey(topic),
-        initiator: true
-      }).stream,
+      stream: stream1,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
@@ -118,36 +104,17 @@ describe('WebRTCTransportProxy', () => {
     });
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
-    const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-    const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+    const stream2 = new TestStream();
     const { webRTCTransportProxy: connection2 } = await setupProxy({
       initiator: false,
-      stream: protocolProvider2({
-        channel: discoveryKey(topic),
-        initiator: false
-      }).stream,
+      stream: stream2,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
       }
     });
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
-
-    const received: any[] = [];
-    const mockReceive = (p: Protocol, s: string) => {
-      received.push(p, s);
-      return undefined;
-    };
-    plugin1.on('receive', mockReceive);
-
-    plugin2.on('connect', async (protocol) => {
-      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-    });
-    await waitForExpect(() => {
-      expect(received.length).toBe(2);
-      expect(received[0]).toBeInstanceOf(Protocol);
-      expect(received[1]).toBe('{"message": "Hello"}');
-    });
+    await TestStream.assertConnectivity(stream1, stream2);
   })
     .timeout(2_000)
     .retries(3);
@@ -192,18 +159,10 @@ describe('WebRTCTransportProxy', () => {
     });
 
     test('establish connection and send data through with protocol', async () => {
-      const topic = PublicKey.random();
-      const peer1Id = PublicKey.random();
-      const peer2Id = PublicKey.random();
-
-      const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-      const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+      const stream1 = new TestStream();
       const proxy1 = new WebRTCTransportProxy({
         initiator: true,
-        stream: protocolProvider1({
-          channel: discoveryKey(topic),
-          initiator: true
-        }).stream,
+        stream: stream1,
         sendSignal: async (signal) => {
           await sleep(10);
           await proxy2.signal(signal);
@@ -212,14 +171,10 @@ describe('WebRTCTransportProxy', () => {
       });
       afterTest(() => proxy1.errors.assertNoUnhandledErrors());
 
-      const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-      const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+      const stream2 = new TestStream();
       const proxy2 = new WebRTCTransportProxy({
         initiator: false,
-        stream: protocolProvider2({
-          channel: discoveryKey(topic),
-          initiator: false
-        }).stream,
+        stream: stream2,
         sendSignal: async (signal) => {
           await sleep(10);
           await proxy1.signal(signal);
@@ -228,22 +183,7 @@ describe('WebRTCTransportProxy', () => {
       });
       afterTest(() => proxy2.errors.assertNoUnhandledErrors());
 
-      const received: any[] = [];
-      const mockReceive = (p: Protocol, s: string) => {
-        received.push(p, s);
-        return undefined;
-      };
-      plugin1.on('receive', mockReceive);
-
-      plugin2.on('connect', async (protocol) => {
-        await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-      });
-
-      await waitForExpect(() => {
-        expect(received.length).toBe(2);
-        expect(received[0]).toBeInstanceOf(Protocol);
-        expect(received[1]).toBe('{"message": "Hello"}');
-      });
+      await TestStream.assertConnectivity(stream1, stream2);
     })
       .timeout(5_000)
       .retries(3);

package/src/transport/webrtc-transport.test.ts

@@ -4,15 +4,10 @@
 
 import expect from 'expect';
 import { Duplex } from 'stream';
-import waitForExpect from 'wait-for-expect';
 
-import { sleep } from '@dxos/async';
-import { discoveryKey } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
-import { describe, test, afterTest } from '@dxos/test';
+import { sleep, TestStream } from '@dxos/async';
+import { afterTest, describe, test } from '@dxos/test';
 
-import { TestProtocolPlugin, testProtocolProvider } from '../testing';
 import { WebRTCTransport } from './webrtc-transport';
 
 describe('WebRTCTransport', () => {
@@ -40,18 +35,10 @@ describe('WebRTCTransport', () => {
     .retries(3);
 
   test('establish connection and send data through with protocol', async () => {
-    const topic = PublicKey.random();
-    const peer1Id = PublicKey.random();
-    const peer2Id = PublicKey.random();
-
-    const plugin1 = new TestProtocolPlugin(peer1Id.asBuffer());
-    const protocolProvider1 = testProtocolProvider(topic.asBuffer(), peer1Id, plugin1);
+    const stream1 = new TestStream();
     const connection1 = new WebRTCTransport({
       initiator: true,
-      stream: protocolProvider1({
-        channel: discoveryKey(topic),
-        initiator: true
-      }).stream,
+      stream: stream1,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection2.signal(signal);
@@ -60,14 +47,10 @@ describe('WebRTCTransport', () => {
     afterTest(() => connection1.destroy());
     afterTest(() => connection1.errors.assertNoUnhandledErrors());
 
-    const plugin2 = new TestProtocolPlugin(peer2Id.asBuffer());
-    const protocolProvider2 = testProtocolProvider(topic.asBuffer(), peer2Id, plugin2);
+    const stream2 = new TestStream();
     const connection2 = new WebRTCTransport({
       initiator: false,
-      stream: protocolProvider2({
-        channel: discoveryKey(topic),
-        initiator: false
-      }).stream,
+      stream: stream2,
       sendSignal: async (signal) => {
         await sleep(10);
         await connection1.signal(signal);
@@ -76,21 +59,7 @@ describe('WebRTCTransport', () => {
     afterTest(() => connection2.destroy());
     afterTest(() => connection2.errors.assertNoUnhandledErrors());
 
-    const received: any[] = [];
-    const mockReceive = (p: Protocol, s: string) => {
-      received.push(p, s);
-      return undefined;
-    };
-    plugin1.on('receive', mockReceive);
-    plugin2.on('connect', async (protocol) => {
-      await plugin2.send(peer1Id.asBuffer(), '{"message": "Hello"}');
-    });
-
-    await waitForExpect(() => {
-      expect(received.length).toBe(2);
-      expect(received[0]).toBeInstanceOf(Protocol);
-      expect(received[1]).toBe('{"message": "Hello"}');
-    });
+    await TestStream.assertConnectivity(stream1, stream2);
   })
     .timeout(2_000)
     .retries(3);

package/src/wire-protocol.ts

@@ -4,13 +4,9 @@
 
 import { Duplex } from 'node:stream';
 
-import { discoveryKey } from '@dxos/crypto';
 import { PublicKey } from '@dxos/keys';
-import { Protocol } from '@dxos/mesh-protocol';
 import { Teleport } from '@dxos/teleport';
 
-import { MeshProtocolProvider } from './protocol-factory';
-
 export type WireProtocolParams = {
   initiator: boolean;
   localPeerId: PublicKey;
@@ -27,30 +23,10 @@ export type WireProtocolProvider = (params: WireProtocolParams) => WireProtocol;
 export interface WireProtocol {
   stream: Duplex;
 
-  /**
-   * @deprecated Only for devtools comapatibility.
-   */
-  protocol?: Protocol;
-
   initialize(): Promise<void>;
   destroy(): Promise<void>;
 }
 
-/**
- * @deprecated
- */
-export const adaptProtocolProvider =
-  (factory: MeshProtocolProvider): WireProtocolProvider =>
-  ({ initiator, localPeerId, remotePeerId, topic }) => {
-    const protocol = factory({ channel: discoveryKey(topic), initiator });
-    return {
-      initialize: () => protocol.open(),
-      destroy: () => protocol.close(),
-      stream: protocol.stream,
-      protocol
-    };
-  };
-
 /**
  * Create a wire-protocol provider backed by a teleport instance.
  * @param onConnection Called after teleport is initialized for the session. Protocol extensions could be attached here.

package/dist/types/src/protocol-factory.d.ts

@@ -1,36 +0,0 @@
-/// <reference types="node" />
-import { PublicKey } from '@dxos/keys';
-import { Extension, Protocol } from '@dxos/mesh-protocol';
-interface ProtocolFactoryOptions {
-    plugins: any[];
-    getTopics: () => Buffer[];
-    session: Record<string, any>;
-}
-/**
- * @deprecated Replaced by WireProtocolProvider.
- */
-export declare type MeshProtocolProvider = (params: {
-    channel: Buffer;
-    initiator: boolean;
-}) => Protocol;
-/**
- * Returns a function that takes a channel parameter, returns a Protocol object
- * with its context set to channel, plugins from plugins parameter and session
- * set to session parameter.
- *
- * @param plugins array of Protocol plugin objects to add to created Protocol objects
- * @param getTopics retrieve a list of known topic keys to encrypt by public key.
- * @deprecated Use `createProtocolFactory`.
- */
-export declare const protocolFactory: ({ session, plugins, getTopics }: ProtocolFactoryOptions) => MeshProtocolProvider;
-export interface Plugin {
-    createExtension: () => Extension;
-}
-export declare const createProtocolFactory: (topic: PublicKey, peerId: PublicKey, plugins: Plugin[]) => MeshProtocolProvider;
-/**
- * Creates a ProtocolProvider for simple transport connections with only one protocol plugin.
- * @deprecated Use `createProtocolFactory`.
- */
-export declare const transportProtocolProvider: (rendezvousKey: Buffer, peerId: Buffer, protocolPlugin: any) => MeshProtocolProvider;
-export {};
-//# sourceMappingURL=protocol-factory.d.ts.map

package/dist/types/src/protocol-factory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protocol-factory.d.ts","sourceRoot":"","sources":["../../../src/protocol-factory.ts"],"names":[],"mappings":";AAOA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE1D,UAAU,sBAAsB;IAC9B,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,oBAAY,oBAAoB,GAAG,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,KAAK,QAAQ,CAAC;AAEjG;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,oCAIzB,sBAAsB,KAAG,oBAyB3B,CAAC;AAEF,MAAM,WAAW,MAAM;IACrB,eAAe,EAAE,MAAM,SAAS,CAAC;CAClC;AAED,eAAO,MAAM,qBAAqB,UAAW,SAAS,UAAU,SAAS,WAAW,MAAM,EAAE,yBAKxF,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,yBAAyB,kBACrB,MAAM,UACb,MAAM,kBACE,GAAG,KAClB,oBAMF,CAAC"}

package/dist/types/src/testing/test-protocol.d.ts

@@ -1,52 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { EventEmitter } from 'node:events';
-import { PublicKey } from '@dxos/keys';
-import { Extension, Protocol } from '@dxos/mesh-protocol';
-export declare const getPeerId: (protocol: Protocol) => Buffer | undefined;
-/**
- * @deprecated
- */
-export declare const testProtocolProvider: (topic: Buffer, peerId: PublicKey, protocolPlugin: any) => import("../protocol-factory").MeshProtocolProvider;
-/**
- * Object Implementing a p2p protocol (interaction across a set of peers using a common protocol)
- * and an associated transport connection protocol (interaction with each individual peer over a single network
- * transport connection).
- */
-export declare class TestProtocolPlugin extends EventEmitter {
-    /** @type {Map<string, {Protocol}>} */
-    private readonly _peers;
-    /** @type {Buffer} */
-    _peerId: Buffer;
-    /** @type {Boolean} */
-    _uppercase: boolean;
-    initCalled: boolean;
-    /**
-     * Test Protocol. Passes through messages unchanged, or folds to upper case.
-     * Provides a way to test that two protocols with different behavior are
-     * indeed being used with two different swarm keys.
-     * @param {Buffer} peerId
-     * @param {Boolean} uppercase Fold payload case to upper if set.
-     */
-    constructor(peerId: Buffer, uppercase?: boolean);
-    get peerId(): Buffer;
-    get peers(): any[];
-    /**
-     * Factory function for Extensions (per-connection object).
-     * Called when a new peer transport connection is established.
-     * @return {Extension}
-     */
-    createExtension(): Extension;
-    private _init;
-    /**
-     * Send/Receive messages with peer when initiating a request/response interaction.
-     * @param peerId Must be the value passed to the constructor on the responding node.
-     * @param payload Message to send
-     * @return Message received from peer in response to our request.
-     */
-    send(peerId: Buffer, payload: string): Promise<string>;
-    _receive(protocol: Protocol, data: any): Promise<void>;
-    _onPeerConnect(protocol: Protocol): Promise<void>;
-    _onPeerDisconnect(protocol: Protocol): Promise<void>;
-}
-//# sourceMappingURL=test-protocol.d.ts.map

package/dist/types/src/testing/test-protocol.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-protocol.d.ts","sourceRoot":"","sources":["../../../../src/testing/test-protocol.ts"],"names":[],"mappings":";;AAOA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAQ1D,eAAO,MAAM,SAAS,aAAc,QAAQ,uBAO3C,CAAC;AAEF;;GAEG;AAEH,eAAO,MAAM,oBAAoB,UAAW,MAAM,UAAU,SAAS,kBAAkB,GAAG,uDAQzF,CAAC;AAEF;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,sCAAsC;IACtC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IAEpC,qBAAqB;IACrB,OAAO,SAAC;IAER,sBAAsB;IACtB,UAAU,UAAC;IAEX,UAAU,UAAS;IAEnB;;;;;;OAMG;gBACS,MAAM,EAAE,MAAM,EAAE,SAAS,UAAQ;IAU7C,IAAI,MAAM,WAET;IAGD,IAAI,KAAK,UAER;IAED;;;;OAIG;IACH,eAAe;YAYD,KAAK;IAInB;;;;;OAKG;IACG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAetD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG;IAYtC,cAAc,CAAC,QAAQ,EAAE,QAAQ;IAgBjC,iBAAiB,CAAC,QAAQ,EAAE,QAAQ;CAU3C"}

package/dist/types/src/tests/presence.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=presence.test.d.ts.map

package/dist/types/src/tests/presence.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"presence.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/presence.test.ts"],"names":[],"mappings":""}

package/src/protocol-factory.ts

@@ -1,88 +0,0 @@
-//
-// Copyright 2020 DXOS.org
-//
-
-import assert from 'node:assert';
-
-import { discoveryKey } from '@dxos/crypto';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { Extension, Protocol } from '@dxos/mesh-protocol';
-
-interface ProtocolFactoryOptions {
-  plugins: any[];
-  getTopics: () => Buffer[];
-  session: Record<string, any>;
-}
-
-/**
- * @deprecated Replaced by WireProtocolProvider.
- */
-export type MeshProtocolProvider = (params: { channel: Buffer; initiator: boolean }) => Protocol;
-
-/**
- * Returns a function that takes a channel parameter, returns a Protocol object
- * with its context set to channel, plugins from plugins parameter and session
- * set to session parameter.
- *
- * @param plugins array of Protocol plugin objects to add to created Protocol objects
- * @param getTopics retrieve a list of known topic keys to encrypt by public key.
- * @deprecated Use `createProtocolFactory`.
- */
-export const protocolFactory = ({
-  session = {},
-  plugins = [],
-  getTopics
-}: ProtocolFactoryOptions): MeshProtocolProvider => {
-  assert(getTopics);
-
-  // eslint-disable-next-line no-unused-vars
-  return ({ channel, initiator }) => {
-    log('creating protocol');
-    const protocol = new Protocol({
-      streamOptions: { live: true },
-      discoveryToPublicKey: (dk) => {
-        const publicKey = getTopics().find((topic) => discoveryKey(topic).equals(dk));
-        if (publicKey) {
-          protocol.setContext({ topic: PublicKey.stringify(publicKey) });
-        }
-
-        assert(publicKey, 'PublicKey not found in discovery.');
-        return publicKey;
-      },
-      initiator,
-      userSession: session,
-      discoveryKey: channel
-    });
-
-    protocol.setExtensions(plugins.map((plugin) => plugin.createExtension())).init();
-    return protocol;
-  };
-};
-
-export interface Plugin {
-  createExtension: () => Extension;
-}
-
-export const createProtocolFactory = (topic: PublicKey, peerId: PublicKey, plugins: Plugin[]) =>
-  protocolFactory({
-    getTopics: () => [topic.asBuffer()],
-    session: { peerId: PublicKey.stringify(peerId.asBuffer()) },
-    plugins
-  });
-
-/**
- * Creates a ProtocolProvider for simple transport connections with only one protocol plugin.
- * @deprecated Use `createProtocolFactory`.
- */
-export const transportProtocolProvider = (
-  rendezvousKey: Buffer,
-  peerId: Buffer,
-  protocolPlugin: any
-): MeshProtocolProvider => {
-  return protocolFactory({
-    getTopics: () => [rendezvousKey],
-    session: { peerId: PublicKey.stringify(peerId) },
-    plugins: [protocolPlugin]
-  });
-};