@dxos/messaging 0.6.8-main.3be982f → 0.6.8-staging.63bcb81

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

@@ -3,20 +3,25 @@
 //
 
 import { Event, sleep, synchronized } from '@dxos/async';
-import { type Any } from '@dxos/codec-protobuf';
-import { Context } from '@dxos/context';
+import { LifecycleState, Resource } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { RateLimitExceededError, TimeoutError, trace } from '@dxos/protocols';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
-import { type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
 import { BitField, safeAwaitAll } from '@dxos/util';
 
 import { type SignalManager } from './signal-manager';
 import { WebsocketSignalManagerMonitor } from './websocket-signal-manager-monitor';
 import { SignalClient } from '../signal-client';
-import { type SignalClientMethods, type SignalMethods, type SignalStatus } from '../signal-methods';
+import {
+  type PeerInfo,
+  type Message,
+  type SignalClientMethods,
+  type SignalMethods,
+  type SignalStatus,
+  type SwarmEvent,
+} from '../signal-methods';
 
 const MAX_SERVER_FAILURES = 5;
 const WSS_SIGNAL_SERVER_REBOOT_DELAY = 3_000;
@@ -24,7 +29,7 @@ const WSS_SIGNAL_SERVER_REBOOT_DELAY = 3_000;
 /**
  * Manages connection to multiple Signal Servers over WebSocket
  */
-export class WebsocketSignalManager implements SignalManager {
+export class WebsocketSignalManager extends Resource implements SignalManager {
   private readonly _servers = new Map<string, SignalClientMethods>();
   private readonly _monitor = new WebsocketSignalManagerMonitor();
 
@@ -33,21 +38,11 @@ export class WebsocketSignalManager implements SignalManager {
    */
   private readonly _failedServersBitfield: Uint8Array;
 
-  private _ctx!: Context;
-  private _opened = false;
-
   readonly failureCount = new Map<string, number>();
   readonly statusChanged = new Event<SignalStatus[]>();
-  readonly swarmEvent = new Event<{
-    topic: PublicKey;
-    swarmEvent: SwarmEvent;
-  }>();
+  readonly swarmEvent = new Event<SwarmEvent>();
 
-  readonly onMessage = new Event<{
-    author: PublicKey;
-    recipient: PublicKey;
-    payload: Any;
-  }>();
+  readonly onMessage = new Event<Message>();
 
   private readonly _instanceId = PublicKey.random().toHex();
 
@@ -55,6 +50,7 @@ export class WebsocketSignalManager implements SignalManager {
     private readonly _hosts: Runtime.Services.Signal[],
     private readonly _getMetadata?: () => any,
   ) {
+    super();
     log('Created WebsocketSignalManager', { hosts: this._hosts });
     for (const host of this._hosts) {
       if (this._servers.has(host.server)) {
@@ -74,35 +70,22 @@ export class WebsocketSignalManager implements SignalManager {
     this._failedServersBitfield = BitField.zeros(this._hosts.length);
   }
 
-  @synchronized
-  async open() {
-    if (this._opened) {
-      return;
-    }
+  protected override async _open() {
     log('open signal manager', { hosts: this._hosts });
     log.trace('dxos.mesh.websocket-signal-manager.open', trace.begin({ id: this._instanceId }));
 
-    this._initContext();
-
     await safeAwaitAll(this._servers.values(), (server) => server.open());
 
-    this._opened = true;
     log.trace('dxos.mesh.websocket-signal-manager.open', trace.end({ id: this._instanceId }));
   }
 
-  @synchronized
-  async close() {
-    if (!this._opened) {
-      return;
-    }
-    this._opened = false;
-    await this._ctx.dispose();
+  protected override async _close() {
     await safeAwaitAll(this._servers.values(), (server) => server.close());
   }
 
   async restartServer(serverName: string) {
     log('restarting server', { serverName });
-    invariant(this._opened, 'server already closed');
+    invariant(this._lifecycleState === LifecycleState.OPEN);
 
     const server = this._servers.get(serverName);
     invariant(server, 'server not found');
@@ -117,30 +100,22 @@ export class WebsocketSignalManager implements SignalManager {
   }
 
   @synchronized
-  async join({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) {
-    log('join', { topic, peerId });
-    invariant(this._opened, 'Closed');
-    await this._forEachServer((server) => server.join({ topic, peerId }));
+  async join({ topic, peer }: { topic: PublicKey; peer: PeerInfo }) {
+    log('join', { topic, peer });
+    invariant(this._lifecycleState === LifecycleState.OPEN);
+    await this._forEachServer((server) => server.join({ topic, peer }));
   }
 
   @synchronized
-  async leave({ topic, peerId }: { topic: PublicKey; peerId: PublicKey }) {
-    log('leaving', { topic, peerId });
-    invariant(this._opened, 'Closed');
-    await this._forEachServer((server) => server.leave({ topic, peerId }));
+  async leave({ topic, peer }: { topic: PublicKey; peer: PeerInfo }) {
+    log('leaving', { topic, peer });
+    invariant(this._lifecycleState === LifecycleState.OPEN);
+    await this._forEachServer((server) => server.leave({ topic, peer }));
   }
 
-  async sendMessage({
-    author,
-    recipient,
-    payload,
-  }: {
-    author: PublicKey;
-    recipient: PublicKey;
-    payload: Any;
-  }): Promise<void> {
+  async sendMessage({ author, recipient, payload }: Message): Promise<void> {
     log('signal', { recipient });
-    invariant(this._opened, 'Closed');
+    invariant(this._lifecycleState === LifecycleState.OPEN);
 
     void this._forEachServer(async (server, serverName, index) => {
       void server
@@ -187,24 +162,18 @@ export class WebsocketSignalManager implements SignalManager {
     }
   }
 
-  async subscribeMessages(peerId: PublicKey) {
-    log('subscribed for message stream', { peerId });
-    invariant(this._opened, 'Closed');
+  async subscribeMessages(peer: PeerInfo) {
+    log('subscribed for message stream', { peer });
+    invariant(this._lifecycleState === LifecycleState.OPEN);
 
-    await this._forEachServer(async (server) => server.subscribeMessages(peerId));
+    await this._forEachServer(async (server) => server.subscribeMessages(peer));
   }
 
-  async unsubscribeMessages(peerId: PublicKey) {
-    log('subscribed for message stream', { peerId });
-    invariant(this._opened, 'Closed');
+  async unsubscribeMessages(peer: PeerInfo) {
+    log('subscribed for message stream', { peer });
+    invariant(this._lifecycleState === LifecycleState.OPEN);
 
-    await this._forEachServer(async (server) => server.unsubscribeMessages(peerId));
-  }
-
-  private _initContext() {
-    this._ctx = new Context({
-      onError: (err) => log.catch(err),
-    });
+    await this._forEachServer(async (server) => server.unsubscribeMessages(peer));
   }
 
   private async _forEachServer<ReturnType>(

package/src/signal-methods.ts

@@ -3,12 +3,17 @@
 //
 
 import { type Event } from '@dxos/async';
+import { type Lifecycle } from '@dxos/context';
 import { type PublicKey } from '@dxos/keys';
-import { type SwarmEvent, type SignalState } from '@dxos/protocols/proto/dxos/mesh/signal';
+import { type Peer } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type SignalState } from '@dxos/protocols/proto/dxos/mesh/signal';
+
+export type PeerInfo = Partial<Peer> & Required<Pick<Peer, 'peerKey'>>;
+export const PeerInfoHash = ({ peerKey }: PeerInfo) => peerKey;
 
 export interface Message {
-  author: PublicKey;
-  recipient: PublicKey;
+  author: PeerInfo;
+  recipient: PeerInfo;
   payload: {
     type_url: string;
     value: Uint8Array;
@@ -24,6 +29,25 @@ export type SignalStatus = {
   lastStateChange: Date;
 };
 
+export type SwarmEvent = {
+  topic: PublicKey;
+
+  /**
+   * The peer was announced as available on the swarm.
+   */
+  peerAvailable?: {
+    peer: PeerInfo;
+    since: Date;
+  };
+
+  /**
+   * The peer left, or their announcement timed out.
+   */
+  peerLeft?: {
+    peer: PeerInfo;
+  };
+};
+
 /**
  * Message routing interface.
  */
@@ -31,7 +55,7 @@ export interface SignalMethods {
   /**
    * Emits when other peers join or leave the swarm.
    */
-  swarmEvent: Event<{ topic: PublicKey; swarmEvent: SwarmEvent }>;
+  swarmEvent: Event<SwarmEvent>;
 
   /**
    * Emits when a message is received.
@@ -41,12 +65,12 @@ export interface SignalMethods {
   /**
    * Join topic on signal network, to be discoverable by other peers.
    */
-  join: (params: { topic: PublicKey; peerId: PublicKey }) => Promise<void>;
+  join: (params: { topic: PublicKey; peer: PeerInfo }) => Promise<void>;
 
   /**
    * Leave topic on signal network, to stop being discoverable by other peers.
    */
-  leave: (params: { topic: PublicKey; peerId: PublicKey }) => Promise<void>;
+  leave: (params: { topic: PublicKey; peer: PeerInfo }) => Promise<void>;
 
   /**
    * Send message to peer.
@@ -57,19 +81,17 @@ export interface SignalMethods {
    * Start receiving messages from peer.
    */
   // TODO(burdon): Return unsubscribe function. Encapsulate callback/routing here.
-  subscribeMessages: (peerId: PublicKey) => Promise<void>;
+  subscribeMessages: (peer: PeerInfo) => Promise<void>;
 
   /**
    * Stop receiving messages from peer.
    */
-  unsubscribeMessages: (peerId: PublicKey) => Promise<void>;
+  unsubscribeMessages: (peer: PeerInfo) => Promise<void>;
 }
 
 /**
  * Signaling client.
  */
-export interface SignalClientMethods extends SignalMethods {
-  open(): Promise<this>;
-  close(): Promise<this>;
+export interface SignalClientMethods extends SignalMethods, Required<Lifecycle> {
   getStatus(): SignalStatus;
 }

package/src/testing/index.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './test-builder';
+export * from './test-peer';
+export * from './test-messages';
+export * from './utils';

package/src/testing/test-builder.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { type PublicKey } from '@dxos/keys';
+
+import { TestPeer } from './test-peer';
+import { type SignalManager, MemorySignalManager, MemorySignalManagerContext } from '../signal-manager';
+import { type Message } from '../signal-methods';
+
+export type TestBuilderOptions = {
+  signalManagerFactory?: (identityKey: PublicKey, deviceKey: PublicKey) => Promise<SignalManager>;
+  messageDisruption?: (msg: Message) => Message[];
+};
+
+export class TestBuilder {
+  private _signalContext = new MemorySignalManagerContext();
+  private readonly _peers: TestPeer[] = [];
+
+  constructor(public options: TestBuilderOptions) {}
+
+  async createSignalManager(identityKey: PublicKey, deviceKey: PublicKey) {
+    const signalManager =
+      (await this.options.signalManagerFactory?.(identityKey, deviceKey)) ??
+      new MemorySignalManager(this._signalContext);
+
+    if (this.options.messageDisruption) {
+      // Imitates signal network disruptions (e. g. message doubling, ).
+      const trueSend = signalManager.sendMessage.bind(signalManager);
+      signalManager.sendMessage = async (message: Message) => {
+        for (const msg of this.options.messageDisruption!(message)) {
+          await trueSend(msg);
+        }
+      };
+    }
+
+    return signalManager;
+  }
+
+  async createPeer(): Promise<TestPeer> {
+    const peer = new TestPeer(this);
+    await peer.open();
+    this._peers.push(peer);
+    return peer;
+  }
+
+  async createPeers(count: number): Promise<TestPeer[]> {
+    return Promise.all(Array.from({ length: count }, () => this.createPeer()));
+  }
+
+  async close() {
+    await Promise.all(this._peers.map((peer) => peer.close()));
+  }
+}

package/src/testing/test-messages.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { type TaggedType } from '@dxos/codec-protobuf';
+import { type TYPES } from '@dxos/protocols';
+
+export const PAYLOAD_1: TaggedType<TYPES, 'google.protobuf.Any'> = {
+  '@type': 'google.protobuf.Any',
+  type_url: 'dxos.Example1',
+  value: Buffer.from('1'),
+};
+
+export const PAYLOAD_2: TaggedType<TYPES, 'google.protobuf.Any'> = {
+  '@type': 'google.protobuf.Any',
+  type_url: 'dxos.Example2',
+  value: Buffer.from('2'),
+};
+
+export const PAYLOAD_3: TaggedType<TYPES, 'google.protobuf.Any'> = {
+  '@type': 'google.protobuf.Any',
+  type_url: 'dxos.Example3',
+  value: Buffer.from('3'),
+};

package/src/testing/test-peer.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { Event } from '@dxos/async';
+import { Resource } from '@dxos/context';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { type TestBuilder } from './test-builder';
+import { expectPeerAvailable, expectPeerLeft, expectReceivedMessage } from './utils';
+import { Messenger } from '../messenger';
+import { type SignalManager } from '../signal-manager';
+import { type Message, type PeerInfo } from '../signal-methods';
+
+export class TestPeer extends Resource {
+  public peerId = PublicKey.random();
+  public identityKey = PublicKey.random();
+  public signalManager!: SignalManager;
+  public messenger!: Messenger;
+  public defaultReceived = new Event<Message>();
+
+  constructor(private readonly testBuilder: TestBuilder) {
+    super();
+  }
+
+  get peerInfo(): PeerInfo {
+    return {
+      peerKey: this.peerId.toHex(),
+      identityKey: this.identityKey.toHex(),
+    };
+  }
+
+  async waitTillReceive(message: Message) {
+    return expectReceivedMessage(this.defaultReceived, message);
+  }
+
+  async waitForPeerAvailable(topic: PublicKey, peer: PeerInfo) {
+    return expectPeerAvailable(this.signalManager, topic, peer);
+  }
+
+  async waitForPeerLeft(topic: PublicKey, peer: PeerInfo) {
+    return expectPeerLeft(this.signalManager, topic, peer);
+  }
+
+  protected override async _open() {
+    this.signalManager = await this.testBuilder.createSignalManager(this.identityKey, this.peerId);
+    this.messenger = new Messenger({ signalManager: this.signalManager });
+
+    await this.signalManager.open();
+    this.messenger.open();
+    await this.messenger
+      .listen({
+        peer: this.peerInfo,
+        onMessage: async (msg) => {
+          this.defaultReceived.emit(msg);
+        },
+      })
+      .catch((err) => log.catch(err));
+  }
+
+  protected override async _close() {
+    await this.messenger.close();
+    await this.signalManager.close();
+  }
+}

package/src/testing/utils.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import { asyncTimeout, type Event } from '@dxos/async';
+import { type Any } from '@dxos/codec-protobuf';
+import { PublicKey } from '@dxos/keys';
+
+import { PAYLOAD_1 } from './test-messages';
+import { type SignalMethods, type Message, type PeerInfo } from '../signal-methods';
+
+export const expectPeerAvailable = (client: SignalMethods, expectedTopic: PublicKey, peer: PeerInfo) =>
+  asyncTimeout(
+    client.swarmEvent.waitFor(
+      ({ peerAvailable, topic }) =>
+        !!peerAvailable && peer.peerKey === peerAvailable.peer.peerKey && expectedTopic.equals(topic),
+    ),
+    1000,
+  );
+
+export const expectPeerLeft = (client: SignalMethods, expectedTopic: PublicKey, peer: PeerInfo) =>
+  asyncTimeout(
+    client.swarmEvent.waitFor(
+      ({ peerLeft, topic }) => !!peerLeft && peer.peerKey === peerLeft.peer.peerKey && expectedTopic.equals(topic),
+    ),
+    1000,
+  );
+
+export const expectReceivedMessage = (event: Event<Message>, expectedMessage: Message) => {
+  return asyncTimeout(
+    event.waitFor(
+      (msg) =>
+        msg.author.peerKey === expectedMessage.author.peerKey &&
+        msg.recipient.peerKey === expectedMessage.recipient.peerKey &&
+        PublicKey.from(msg.payload.value).equals(expectedMessage.payload.value),
+    ),
+    5000,
+  );
+};
+
+export const createMessage = (author: PeerInfo, recipient: PeerInfo, payload: Any = PAYLOAD_1): Message => ({
+  author,
+  recipient,
+  payload,
+});
+
+export const messageEqual = (msg1: Message, msg2: Message) =>
+  msg1.author.peerKey === msg2.author.peerKey &&
+  msg1.recipient.peerKey === msg2.recipient.peerKey &&
+  PublicKey.from(msg1.payload.value).equals(msg2.payload.value);

package/dist/types/src/testing.d.ts

@@ -1,40 +0,0 @@
-import { Event } from '@dxos/async';
-import { PublicKey } from '@dxos/keys';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
-import { Messenger } from './messenger';
-import { type SignalManager } from './signal-manager';
-import { type SignalMethods, type Message } from './signal-methods';
-export type TestBuilderOptions = {
-    signalHosts?: Runtime.Services.Signal[];
-    messageDisruption?: (msg: Message) => Message[];
-};
-export declare class TestBuilder {
-    options: TestBuilderOptions;
-    private _signalContext;
-    private readonly _peers;
-    constructor(options: TestBuilderOptions);
-    createSignalManager(): SignalManager;
-    createPeer(): TestPeer;
-    close(): Promise<void>;
-}
-export declare class TestPeer {
-    private readonly testBuilder;
-    peerId: PublicKey;
-    signalManager: SignalManager;
-    messenger: Messenger;
-    defaultReceived: Event<Message>;
-    constructor(testBuilder: TestBuilder);
-    waitTillReceive(message: Message): Promise<Message>;
-    open(): Promise<void>;
-    close(): Promise<void>;
-}
-export declare const expectPeerAvailable: (client: SignalMethods, expectedTopic: PublicKey, peer: PublicKey) => Promise<{
-    topic: PublicKey;
-    swarmEvent: import("packages/core/protocols/dist/esm/src/proto/gen/dxos/mesh/signal").SwarmEvent;
-}>;
-export declare const expectPeerLeft: (client: SignalMethods, expectedTopic: PublicKey, peer: PublicKey) => Promise<{
-    topic: PublicKey;
-    swarmEvent: import("packages/core/protocols/dist/esm/src/proto/gen/dxos/mesh/signal").SwarmEvent;
-}>;
-export declare const expectReceivedMessage: (client: SignalMethods, expectedMessage: Message) => Promise<Message>;
-//# sourceMappingURL=testing.d.ts.map

package/dist/types/src/testing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../../src/testing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAEjE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EACL,KAAK,aAAa,EAInB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IACxC,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,EAAE,CAAC;CACjD,CAAC;AAEF,qBAAa,WAAW;IAIH,OAAO,EAAE,kBAAkB;IAH9C,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;gBAEtB,OAAO,EAAE,kBAAkB;IAE9C,mBAAmB;IAqBnB,UAAU,IAAI,QAAQ;IAMhB,KAAK;CAGZ;AAED,qBAAa,QAAQ;IAMP,OAAO,CAAC,QAAQ,CAAC,WAAW;IALjC,MAAM,YAAsB;IAC5B,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,eAAe,iBAAwB;gBAEjB,WAAW,EAAE,WAAW;IAKrD,eAAe,CAAC,OAAO,EAAE,OAAO;IAS1B,IAAI;IAaJ,KAAK;CAIZ;AAED,eAAO,MAAM,mBAAmB,WAAY,aAAa,iBAAiB,SAAS,QAAQ,SAAS;;;EAIjG,CAAC;AAEJ,eAAO,MAAM,cAAc,WAAY,aAAa,iBAAiB,SAAS,QAAQ,SAAS;;;EAI5F,CAAC;AAEJ,eAAO,MAAM,qBAAqB,WAAY,aAAa,mBAAmB,OAAO,qBAOpF,CAAC"}

package/src/testing.ts

@@ -1,120 +0,0 @@
-//
-// Copyright 2022 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { type Runtime } from '@dxos/protocols/proto/dxos/config';
-
-import { Messenger } from './messenger';
-import {
-  type SignalManager,
-  MemorySignalManager,
-  MemorySignalManagerContext,
-  WebsocketSignalManager,
-} from './signal-manager';
-import { type SignalMethods, type Message } from './signal-methods';
-
-export type TestBuilderOptions = {
-  signalHosts?: Runtime.Services.Signal[];
-  messageDisruption?: (msg: Message) => Message[];
-};
-
-export class TestBuilder {
-  private _signalContext = new MemorySignalManagerContext();
-  private readonly _peers: TestPeer[] = [];
-
-  constructor(public options: TestBuilderOptions) {}
-
-  createSignalManager() {
-    let signalManager: SignalManager;
-    if (this.options.signalHosts) {
-      signalManager = new WebsocketSignalManager(this.options.signalHosts);
-    } else {
-      signalManager = new MemorySignalManager(this._signalContext);
-    }
-
-    if (this.options.messageDisruption) {
-      // Imitates signal network disruptions (e. g. message doubling, ).
-      const trueSend = signalManager.sendMessage.bind(signalManager);
-      signalManager.sendMessage = async (message) => {
-        for (const msg of this.options.messageDisruption!(message)) {
-          await trueSend(msg);
-        }
-      };
-    }
-
-    return signalManager;
-  }
-
-  createPeer(): TestPeer {
-    const peer = new TestPeer(this);
-    this._peers.push(peer);
-    return peer;
-  }
-
-  async close() {
-    await Promise.all(this._peers.map((peer) => peer.close()));
-  }
-}
-
-export class TestPeer {
-  public peerId = PublicKey.random();
-  public signalManager: SignalManager;
-  public messenger: Messenger;
-  public defaultReceived = new Event<Message>();
-
-  constructor(private readonly testBuilder: TestBuilder) {
-    this.signalManager = testBuilder.createSignalManager();
-    this.messenger = new Messenger({ signalManager: this.signalManager });
-  }
-
-  waitTillReceive(message: Message) {
-    return this.defaultReceived.waitFor(
-      (msg) =>
-        msg.author.equals(message.author) &&
-        msg.recipient.equals(message.recipient) &&
-        msg.payload.value.every((value, index) => value === message.payload.value[index]),
-    );
-  }
-
-  async open() {
-    await this.signalManager.open();
-    this.messenger.open();
-    await this.messenger
-      .listen({
-        peerId: this.peerId,
-        onMessage: async (msg) => {
-          this.defaultReceived.emit(msg);
-        },
-      })
-      .catch((err) => log.catch(err));
-  }
-
-  async close() {
-    await this.messenger.close();
-    await this.signalManager.close();
-  }
-}
-
-export const expectPeerAvailable = (client: SignalMethods, expectedTopic: PublicKey, peer: PublicKey) =>
-  client.swarmEvent.waitFor(
-    ({ swarmEvent, topic }) =>
-      !!swarmEvent.peerAvailable && peer.equals(swarmEvent.peerAvailable.peer) && expectedTopic.equals(topic),
-  );
-
-export const expectPeerLeft = (client: SignalMethods, expectedTopic: PublicKey, peer: PublicKey) =>
-  client.swarmEvent.waitFor(
-    ({ swarmEvent, topic }) =>
-      !!swarmEvent.peerLeft && peer.equals(swarmEvent.peerLeft.peer) && expectedTopic.equals(topic),
-  );
-
-export const expectReceivedMessage = (client: SignalMethods, expectedMessage: Message) => {
-  return client.onMessage.waitFor(
-    (msg) =>
-      msg.author.equals(expectedMessage.author) &&
-      msg.recipient.equals(expectedMessage.recipient) &&
-      PublicKey.from(msg.payload.value).equals(expectedMessage.payload.value),
-  );
-};