@dxos/network-manager 0.6.8-main.3be982f → 0.6.8-staging.77f93a3

package/src/swarm/swarm.test.ts

@@ -6,7 +6,13 @@ import { expect } from 'chai';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { MemorySignalManager, MemorySignalManagerContext, Messenger, type SignalManager } from '@dxos/messaging';
+import {
+  MemorySignalManager,
+  MemorySignalManagerContext,
+  Messenger,
+  type PeerInfo,
+  type SignalManager,
+} from '@dxos/messaging';
 import { afterTest, describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
@@ -19,7 +25,7 @@ import { createLibDataChannelTransportFactory, createSimplePeerTransportFactory
 
 type TestPeer = {
   swarm: Swarm;
-  peerId: PublicKey;
+  peer: PeerInfo;
   protocol: TestWireProtocol;
   topic: PublicKey;
   signalManager: SignalManager;
@@ -30,21 +36,21 @@ describe('Swarm', () => {
 
   const setupSwarm = async ({
     topic = PublicKey.random(),
-    peerId = PublicKey.random(),
+    peer = { peerKey: PublicKey.random().toHex() },
     connectionLimiter = new ConnectionLimiter(),
     signalManager = new MemorySignalManager(context),
     initiationDelay = 100,
   }: {
     topic?: PublicKey;
-    peerId?: PublicKey;
+    peer?: PeerInfo;
     connectionLimiter?: ConnectionLimiter;
     signalManager?: SignalManager;
     initiationDelay?: number;
   }): Promise<TestPeer> => {
-    const protocol = new TestWireProtocol(peerId);
+    const protocol = new TestWireProtocol(PublicKey.from(peer.peerKey));
     const swarm = new Swarm(
       topic,
-      peerId,
+      peer,
       new FullyConnectedTopology(),
       protocol.factory,
       new Messenger({ signalManager }),
@@ -62,7 +68,7 @@ describe('Swarm', () => {
 
     await swarm.open();
 
-    return { swarm, protocol, topic, peerId, signalManager };
+    return { swarm, protocol, topic, peer, signalManager };
   };
 
   test('connects two peers in a swarm', async () => {
@@ -92,16 +98,16 @@ describe('Swarm', () => {
   test('with simultaneous connections one of the peers drops initiated connection', async () => {
     const topic = PublicKey.random();
 
-    const peerId1 = PublicKey.fromHex('39ba0e42');
-    const peerId2 = PublicKey.fromHex('7d2bc6ab');
+    const peerInfo1 = { peerKey: '39ba0e42' };
+    const peerInfo2 = { peerKey: '7d2bc6ab' };
 
-    const peer1 = await setupSwarm({ peerId: peerId1, topic, initiationDelay: 0 });
-    const peer2 = await setupSwarm({ peerId: peerId2, topic, initiationDelay: 0 });
+    const peer1 = await setupSwarm({ peer: peerInfo1, topic, initiationDelay: 0 });
+    const peer2 = await setupSwarm({ peer: peerInfo2, topic, initiationDelay: 0 });
 
     expect(peer1.swarm.connections.length).to.equal(0);
     expect(peer2.swarm.connections.length).to.equal(0);
 
-    const connectionDisplaced = peer2.swarm._peers.get(peerId1)?.connectionDisplaced.waitForCount(1);
+    const connectionDisplaced = peer2.swarm._peers.get(peerInfo1)?.connectionDisplaced.waitForCount(1);
 
     await connectSwarms(peer1, peer2);
     await asyncTimeout(connectionDisplaced!, 1000);
@@ -125,17 +131,17 @@ describe('Swarm', () => {
   test('connection limiter', async () => {
     // remotePeer1 <--> peer (connectionLimiter: max = 1) <--> remotePeer2
 
-    const peerId = PublicKey.fromHex('7701dc2d');
-    const remotePeerId1 = PublicKey.fromHex('7d2bc6aa');
-    const remotePeerId2 = PublicKey.fromHex('39ba0e41');
+    const localPeerInfo = { peerKey: '7701dc2d' };
+    const remotePeerInfo1 = { peerKey: '7d2bc6aa' };
+    const remotePeerInfo2 = { peerKey: '39ba0e41' };
 
     const topic = PublicKey.random();
     const connectionLimiter = new ConnectionLimiter({ maxConcurrentInitConnections: 1 });
 
     const signalManager = new MemorySignalManager(context);
     const sendOriginal = signalManager.sendMessage.bind(signalManager);
-    const messages = new ComplexSet<{ author: PublicKey; recipient: PublicKey }>(
-      ({ author, recipient }) => author.toHex() + recipient.toHex(),
+    const messages = new ComplexSet<{ author: PeerInfo; recipient: PeerInfo }>(
+      ({ author, recipient }) => author.peerKey + recipient.peerKey,
     );
     signalManager.sendMessage = async (message) => {
       messages.add({ author: message.author, recipient: message.recipient });
@@ -146,12 +152,12 @@ describe('Swarm', () => {
 
     const peer = await setupSwarm({
       topic,
-      peerId,
+      peer: localPeerInfo,
       connectionLimiter,
       signalManager,
     });
-    const remotePeer1 = await setupSwarm({ peerId: remotePeerId1, topic });
-    const remotePeer2 = await setupSwarm({ peerId: remotePeerId2, topic });
+    const remotePeer1 = await setupSwarm({ peer: remotePeerInfo1, topic });
+    const remotePeer2 = await setupSwarm({ peer: remotePeerInfo2, topic });
 
     let connected1: Promise<void>;
     {
@@ -171,8 +177,8 @@ describe('Swarm', () => {
 
     {
       // Peer sent messages only to first remote peer.
-      expect(messages.has({ author: peer.peerId, recipient: remotePeer1.peerId })).to.equal(true);
-      expect(messages.has({ author: peer.peerId, recipient: remotePeer2.peerId })).to.equal(false);
+      expect(messages.has({ author: localPeerInfo, recipient: remotePeerInfo1 })).to.equal(true);
+      expect(messages.has({ author: localPeerInfo, recipient: remotePeerInfo2 })).to.equal(false);
     }
 
     signalManager.unfreeze();
@@ -186,8 +192,9 @@ const connectSwarms = async (peer1: TestPeer, peer2: TestPeer, delay = async ()
   const connect2 = peer2.swarm.connected.waitForCount(1);
 
   peer1.swarm.onSwarmEvent({
+    topic: peer2.topic,
     peerAvailable: {
-      peer: peer2.peerId.asUint8Array(),
+      peer: peer2.peer,
       since: new Date(),
     },
   });
@@ -195,15 +202,16 @@ const connectSwarms = async (peer1: TestPeer, peer2: TestPeer, delay = async ()
   await delay();
 
   peer2.swarm.onSwarmEvent({
+    topic: peer1.topic,
     peerAvailable: {
-      peer: peer1.peerId.asUint8Array(),
+      peer: peer1.peer,
       since: new Date(),
     },
   });
 
   if (
     !(
-      peer1.swarm.connections.find((connection) => connection.remoteId.equals(peer2.peerId))?.state ===
+      peer1.swarm.connections.find((connection) => connection.remoteInfo.peerKey === peer2.peer.peerKey)?.state ===
       ConnectionState.CONNECTED
     )
   ) {
@@ -211,13 +219,13 @@ const connectSwarms = async (peer1: TestPeer, peer2: TestPeer, delay = async ()
   }
   if (
     !(
-      peer2.swarm.connections.find((connection) => connection.remoteId.equals(peer1.peerId))?.state ===
+      peer2.swarm.connections.find((connection) => connection.remoteInfo.peerKey === peer1.peer.peerKey)?.state ===
       ConnectionState.CONNECTED
     )
   ) {
     await asyncTimeout(connect2, 3000);
   }
 
-  await peer1.protocol.testConnection(peer2.peerId, 'test message 1');
-  await peer2.protocol.testConnection(peer1.peerId, 'test message 2');
+  await peer1.protocol.testConnection(PublicKey.from(peer2.peer.peerKey), 'test message 1');
+  await peer2.protocol.testConnection(PublicKey.from(peer1.peer.peerKey), 'test message 2');
 };

package/src/swarm/swarm.ts

@@ -8,9 +8,8 @@ import { ErrorStream } from '@dxos/debug';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log, logInfo } from '@dxos/log';
-import { type ListeningHandle, type Messenger } from '@dxos/messaging';
+import { type SwarmEvent, type ListeningHandle, type Messenger, type PeerInfo, PeerInfoHash } from '@dxos/messaging';
 import { trace } from '@dxos/protocols';
-import { type SwarmEvent } from '@dxos/protocols/proto/dxos/mesh/signal';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { ComplexMap, isNotNullOrUndefined } from '@dxos/util';
 
@@ -41,9 +40,10 @@ export class Swarm {
   private _listeningHandle?: ListeningHandle = undefined;
 
   /**
+   * PeerInfo -> Peer.
    * @internal
    */
-  readonly _peers = new ComplexMap<PublicKey, Peer>(PublicKey.hash);
+  readonly _peers = new ComplexMap<PeerInfo, Peer>(PeerInfoHash);
 
   /**
    * Unique id of the swarm, local to the current peer, generated when swarm is joined.
@@ -61,13 +61,13 @@ export class Swarm {
    * Connection to a peer is dropped.
    * @internal
    */
-  readonly disconnected = new Event<PublicKey>();
+  readonly disconnected = new Event<PeerInfo>();
 
   /**
    * Connection is established to a new peer.
    * @internal
    */
-  readonly connected = new Event<PublicKey>();
+  readonly connected = new Event<PeerInfo>();
 
   readonly errors = new ErrorStream();
 
@@ -76,8 +76,7 @@ export class Swarm {
   // TODO(burdon): Pass in object.
   constructor(
     private readonly _topic: PublicKey,
-    // usually the deviceKey
-    private readonly _ownPeerId: PublicKey,
+    private readonly _ownPeer: PeerInfo,
     private _topology: Topology,
     private readonly _protocolProvider: WireProtocolProvider,
     private readonly _messenger: Messenger,
@@ -88,9 +87,9 @@ export class Swarm {
   ) {
     log.trace(
       'dxos.mesh.swarm.constructor',
-      trace.begin({ id: this._instanceId, data: { topic: this._topic.toHex(), peerId: this._ownPeerId.toHex() } }),
+      trace.begin({ id: this._instanceId, data: { topic: this._topic.toHex(), peer: this._ownPeer } }),
     );
-    log('creating swarm', { peerId: _ownPeerId });
+    log('creating swarm', { peerId: _ownPeer });
     _topology.init(this._getSwarmController());
 
     this._swarmMessenger = new SwarmMessenger({
@@ -108,9 +107,13 @@ export class Swarm {
       .filter(isNotNullOrUndefined);
   }
 
-  @logInfo
   get ownPeerId() {
-    return this._ownPeerId;
+    return PublicKey.from(this._ownPeer.peerKey);
+  }
+
+  @logInfo
+  get ownPeer() {
+    return this._ownPeer;
   }
 
   /**
@@ -128,7 +131,7 @@ export class Swarm {
   async open() {
     invariant(!this._listeningHandle);
     this._listeningHandle = await this._messenger.listen({
-      peerId: this._ownPeerId,
+      peer: this._ownPeer,
       payloadType: 'dxos.mesh.swarm.SwarmMessage',
       onMessage: async (message) => {
         await this._swarmMessenger
@@ -176,22 +179,22 @@ export class Swarm {
     }
 
     if (swarmEvent.peerAvailable) {
-      const peerId = PublicKey.from(swarmEvent.peerAvailable.peer);
-      if (!peerId.equals(this._ownPeerId)) {
+      const peerId = swarmEvent.peerAvailable.peer.peerKey;
+      if (peerId !== this._ownPeer.peerKey) {
         log('new peer', { peerId });
-        const peer = this._getOrCreatePeer(peerId);
+        const peer = this._getOrCreatePeer(swarmEvent.peerAvailable.peer);
         peer.advertizing = true;
       }
     } else if (swarmEvent.peerLeft) {
-      const peer = this._peers.get(PublicKey.from(swarmEvent.peerLeft.peer));
+      const peer = this._peers.get(swarmEvent.peerLeft.peer);
       if (peer) {
         peer.advertizing = false;
         if (peer.connection?.state !== ConnectionState.CONNECTED) {
           // Destroy peer only if there is no p2p-connection established
-          void this._destroyPeer(peer.id, 'peer left').catch((err) => log.catch(err));
+          void this._destroyPeer(swarmEvent.peerLeft.peer, 'peer left').catch((err) => log.catch(err));
         }
       } else {
-        log('received peerLeft but no peer found', { peer: swarmEvent.peerLeft.peer });
+        log('received peerLeft but no peer found', { peer: swarmEvent.peerLeft.peer.peerKey });
       }
     }
 
@@ -208,7 +211,7 @@ export class Swarm {
 
     // Id of the peer offering us the connection.
     invariant(message.author);
-    if (!message.recipient?.equals(this._ownPeerId)) {
+    if (message.recipient.peerKey !== this._ownPeer.peerKey) {
       log('rejecting offer with incorrect peerId', { message });
       return { accept: false };
     }
@@ -230,7 +233,7 @@ export class Swarm {
       return;
     }
     invariant(
-      message.recipient?.equals(this._ownPeerId),
+      message.recipient.peerKey === this._ownPeer.peerKey,
       `Invalid signal peer id expected=${this.ownPeerId}, actual=${message.recipient}`,
     );
     invariant(message.topic?.equals(this._topic));
@@ -253,13 +256,14 @@ export class Swarm {
     this._ctx = new Context();
   }
 
-  private _getOrCreatePeer(peerId: PublicKey): Peer {
-    let peer = this._peers.get(peerId);
+  private _getOrCreatePeer(peerInfo: PeerInfo): Peer {
+    invariant(peerInfo.peerKey, 'PeerInfo.peerKey is required');
+    let peer = this._peers.get(peerInfo);
     if (!peer) {
       peer = new Peer(
-        peerId,
+        peerInfo,
         this._topic,
-        this._ownPeerId,
+        this._ownPeer,
         this._swarmMessenger,
         this._protocolProvider,
         this._transportFactory,
@@ -269,62 +273,62 @@ export class Swarm {
             this.connectionAdded.emit(connection);
           },
           onConnected: () => {
-            this.connected.emit(peerId);
+            this.connected.emit(peerInfo);
           },
           onDisconnected: async () => {
             if (this._isUnregistered(peer)) {
               return;
             }
             if (!peer!.advertizing) {
-              await this._destroyPeer(peer!.id, 'peer disconnected');
+              await this._destroyPeer(peerInfo, 'peer disconnected');
             }
 
-            this.disconnected.emit(peerId);
+            this.disconnected.emit(peerInfo);
             this._topology.update();
           },
           onRejected: () => {
             // If the peer rejected our connection remove it from the set of candidates.
             // TODO(dmaretskyi): Set flag instead.
             if (!this._isUnregistered(peer)) {
-              log('peer rejected connection', { peerId });
-              void this._destroyPeer(peerId, 'peer rejected connection');
+              log('peer rejected connection', { peerInfo });
+              void this._destroyPeer(peerInfo, 'peer rejected connection');
             }
           },
           onAccepted: () => {
             this._topology.update();
           },
           onOffer: (remoteId) => {
-            return this._topology.onOffer(remoteId);
+            return this._topology.onOffer(PublicKey.from(remoteId.peerKey));
           },
           onPeerAvailable: () => {
             this._topology.update();
           },
         },
       );
-      this._peers.set(peerId, peer);
+      this._peers.set(peerInfo, peer);
     }
 
     return peer;
   }
 
-  private async _destroyPeer(peerId: PublicKey, reason?: string) {
-    const peer = this._peers.get(peerId);
+  private async _destroyPeer(peerInfo: PeerInfo, reason?: string) {
+    const peer = this._peers.get(peerInfo);
     invariant(peer);
-    this._peers.delete(peerId);
+    this._peers.delete(peerInfo);
     await peer.safeDestroy(new Error(reason));
   }
 
   private _getSwarmController(): SwarmController {
     return {
       getState: () => ({
-        ownPeerId: this._ownPeerId,
-        connected: Array.from(this._peers.values())
-          .filter((peer) => peer.connection)
-          .map((peer) => peer.id),
-        candidates: Array.from(this._peers.values())
-          .filter((peer) => !peer.connection && peer.advertizing && peer.availableToConnect)
-          .map((peer) => peer.id),
-        allPeers: Array.from(this._peers.values()).map((peer) => peer.id),
+        ownPeerId: PublicKey.from(this._ownPeer.peerKey),
+        connected: Array.from(this._peers.entries())
+          .filter(([_, peer]) => peer.connection)
+          .map(([info]) => PublicKey.from(info.peerKey)),
+        candidates: Array.from(this._peers.entries())
+          .filter(([_, peer]) => !peer.connection && peer.advertizing && peer.availableToConnect)
+          .map(([info]) => PublicKey.from(info.peerKey)),
+        allPeers: Array.from(this._peers.keys()).map((info) => PublicKey.from(info.peerKey)),
       }),
       connect: (peer) => {
         if (this._ctx.disposed) {
@@ -334,7 +338,7 @@ export class Swarm {
         // Run in a separate non-blocking task.
         scheduleTask(this._ctx, async () => {
           try {
-            await this._initiateConnection(peer);
+            await this._initiateConnection({ peerKey: peer.toHex() });
           } catch (err: any) {
             log('initiation error', err);
           }
@@ -347,7 +351,7 @@ export class Swarm {
 
         // Run in a separate non-blocking task.
         scheduleTask(this._ctx, async () => {
-          await this._closeConnection(peer);
+          await this._closeConnection({ peerKey: peer.toHex() });
           this._topology.update();
         });
       },
@@ -357,14 +361,14 @@ export class Swarm {
   /**
    * Creates a connection then sends message over signal network.
    */
-  private async _initiateConnection(remoteId: PublicKey) {
+  private async _initiateConnection(remotePeer: PeerInfo) {
     const ctx = this._ctx; // Copy to avoid getting reset while sleeping.
 
     // It is likely that the other peer will also try to connect to us at the same time.
     // If our peerId is higher, we will wait for a bit so that other peer has a chance to connect first.
-    const peer = this._getOrCreatePeer(remoteId);
-    if (remoteId.toHex() < this._ownPeerId.toHex()) {
-      log('initiation delay', { remoteId });
+    const peer = this._getOrCreatePeer(remotePeer);
+    if (remotePeer.peerKey < this._ownPeer.peerKey) {
+      log('initiation delay', { remotePeer });
       await sleep(this._initiationDelay);
     }
     if (ctx.disposed) {
@@ -380,14 +384,14 @@ export class Swarm {
       return;
     }
 
-    log('initiating connection...', { remoteId });
+    log('initiating connection...', { remotePeer });
     await peer.initiateConnection();
     this._topology.update();
-    log('initiated', { remoteId });
+    log('initiated', { remotePeer });
   }
 
-  private async _closeConnection(peerId: PublicKey) {
-    const peer = this._peers.get(peerId);
+  private async _closeConnection(peerInfo: PeerInfo) {
+    const peer = this._peers.get(peerInfo);
     if (!peer) {
       return;
     }
@@ -396,6 +400,6 @@ export class Swarm {
   }
 
   private _isUnregistered(peer?: Peer): boolean {
-    return !peer || this._peers.get(peer.id) !== peer;
+    return !peer || this._peers.get(peer.remoteInfo) !== peer;
   }
 }

package/src/testing/test-builder.ts

@@ -227,7 +227,7 @@ export class TestSwarmConnection {
   async join(topology = new FullyConnectedTopology()) {
     await this.peer._networkManager.joinSwarm({
       topic: this.topic,
-      peerId: this.peer.peerId,
+      peerInfo: { peerKey: this.peer.peerId.toHex(), identityKey: this.peer.peerId.toHex() },
       protocolProvider: this.protocol.factory,
       topology,
     });

package/src/tests/basic-test-suite.ts

@@ -147,10 +147,10 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     //
     const connectionDropped = peer2._networkManager
       .getSwarm(topic)
-      ?.disconnected.waitFor((peerId) => peerId.equals(peer1.peerId));
+      ?.disconnected.waitFor(({ peerKey }) => peer1.peerId.equals(peerKey!));
 
     const peerLeft = peer2._signalManager.swarmEvent.waitFor(
-      (event) => !!event.swarmEvent.peerLeft && peer1.peerId.equals(event.swarmEvent.peerLeft?.peer),
+      (event) => !!event.peerLeft && peer1.peerId.equals(event.peerLeft.peer.peerKey),
     );
 
     await peer1.goOffline();
@@ -159,14 +159,17 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
 
     // Wait for peer to be removed from the swarm.
     await waitForExpect(() => {
-      expect(!!peer2._networkManager.getSwarm(topic)!._peers.get(peer1.peerId)?.advertizing).to.be.false;
+      expect(!!peer2._networkManager.getSwarm(topic)!._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing).to.be
+        .false;
     }, 1_000);
 
     await peer1.goOnline();
 
     await waitForExpect(() => {
-      expect(peer1._networkManager.getSwarm(topic)?._peers.get(peer2.peerId)?.advertizing).to.be.true;
-      expect(peer2._networkManager.getSwarm(topic)?._peers.get(peer1.peerId)?.advertizing).to.be.true;
+      expect(peer1._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer2.peerId.toHex() })?.advertizing).to.be
+        .true;
+      expect(peer2._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing).to.be
+        .true;
     }, 2_000);
 
     await exchangeMessages(swarm1, swarm2);

package/src/tests/property-test-suite.ts

@@ -121,7 +121,10 @@ export const propertyTestSuite = () => {
         // const protocol = createProtocolFactory(model.topic, this.peerId, [presence]);
 
         await peer.networkManager.joinSwarm({
-          peerId: this.peerId, // TODO(burdon): `this`?
+          peerInfo: {
+            peerKey: this.peerId.toHex(),
+            identityKey: this.peerId.toHex(),
+          },
           topic: model.topic,
           protocolProvider: todo(),
           topology: new FullyConnectedTopology(),