@dxos/network-manager 0.6.11 → 0.6.12-main.5cc132e

package/package.json

@@ -1,30 +1,43 @@
 {
   "name": "@dxos/network-manager",
-  "version": "0.6.11",
+  "version": "0.6.12-main.5cc132e",
   "description": "Network Manager",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "DXOS.org",
+  "imports": {
+    "#node-datachannel": {
+      "browser": "./module-stub.js",
+      "workerd": "./module-stub.js",
+      "default": "node-datachannel"
+    },
+    "#node-datachannel/*": {
+      "browser": "./module-stub.js",
+      "workerd": "./module-stub.js",
+      "default": "node-datachannel/*"
+    }
+  },
   "exports": {
     ".": {
       "browser": "./dist/lib/browser/index.mjs",
       "node": {
-        "default": "./dist/lib/node/index.cjs"
+        "require": "./dist/lib/node/index.cjs",
+        "default": "./dist/lib/node-esm/index.mjs"
       },
       "types": "./dist/types/src/index.d.ts"
     },
     "./testing": {
       "browser": "./dist/lib/browser/testing/index.mjs",
       "node": {
-        "default": "./dist/lib/node/testing/index.cjs"
+        "require": "./dist/lib/node/testing/index.cjs",
+        "default": "./dist/lib/node-esm/testing/index.mjs"
       },
       "types": "./dist/types/src/testing/index.d.ts"
     }
   },
   "browser": {
-    "./src/transport/tcp-transport.ts": "./src/transport/tcp-transport.browser.ts",
-    "./src/transport/datachannel/index.ts": "./src/transport/datachannel/index.browser.ts"
+    "./src/transport/tcp-transport.ts": "./src/transport/tcp-transport.browser.ts"
   },
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
@@ -42,42 +55,28 @@
   ],
   "dependencies": {
     "@koush/wrtc": "^0.5.3",
-    "isomorphic-ws": "^5.0.0",
-    "nanomessage-rpc": "^3.0.0",
     "node-datachannel": "^0.5.5",
-    "p-defer": "^3.0.0",
     "simple-peer": "9.11.1",
-    "stream": "^0.0.2",
-    "tiny-invariant": "^1.3.1",
-    "ws": "^8.14.2",
-    "xor-distance": "^2.0.0",
-    "@dxos/async": "0.6.11",
-    "@dxos/codec-protobuf": "0.6.11",
-    "@dxos/config": "0.6.11",
-    "@dxos/context": "0.6.11",
-    "@dxos/credentials": "0.6.11",
-    "@dxos/crypto": "0.6.11",
-    "@dxos/edge-client": "0.6.11",
-    "@dxos/invariant": "0.6.11",
-    "@dxos/debug": "0.6.11",
-    "@dxos/keys": "0.6.11",
-    "@dxos/log": "0.6.11",
-    "@dxos/messaging": "0.6.11",
-    "@dxos/protocols": "0.6.11",
-    "@dxos/node-std": "0.6.11",
-    "@dxos/rpc": "0.6.11",
-    "@dxos/teleport": "0.6.11",
-    "@dxos/util": "0.6.11"
+    "stream": "^0.0.3",
+    "@dxos/async": "0.6.12-main.5cc132e",
+    "@dxos/codec-protobuf": "0.6.12-main.5cc132e",
+    "@dxos/context": "0.6.12-main.5cc132e",
+    "@dxos/debug": "0.6.12-main.5cc132e",
+    "@dxos/invariant": "0.6.12-main.5cc132e",
+    "@dxos/keys": "0.6.12-main.5cc132e",
+    "@dxos/messaging": "0.6.12-main.5cc132e",
+    "@dxos/node-std": "0.6.12-main.5cc132e",
+    "@dxos/log": "0.6.12-main.5cc132e",
+    "@dxos/protocols": "0.6.12-main.5cc132e",
+    "@dxos/rpc": "0.6.12-main.5cc132e",
+    "@dxos/teleport": "0.6.12-main.5cc132e",
+    "@dxos/util": "0.6.12-main.5cc132e"
   },
   "devDependencies": {
-    "@swc-node/register": "1.9.1",
     "@types/simple-peer": "9.11.3",
-    "@types/ws": "^7.4.0",
-    "earljs": "~0.1.10",
     "fast-check": "^3.19.0",
     "fetch-mock": "^11.0.0",
-    "typescript": "^5.5.4",
-    "@dxos/signal": "0.6.11"
+    "@dxos/signal": "0.6.12-main.5cc132e"
   },
   "publishConfig": {
     "access": "public"

package/src/signal/ice.test.ts

@@ -2,10 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
 import fetchMock from 'fetch-mock';
-
-import { test, describe } from '@dxos/test';
+import { afterEach, test, expect, describe } from 'vitest';
 
 import { createIceProvider } from './ice';
 

package/src/signal/{integration.test.ts → integration.node.test.ts}

@@ -2,15 +2,11 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/test platform=nodejs
-
-import { expect } from 'earljs';
-import waitForExpect from 'wait-for-expect';
+import { afterAll, onTestFinished, beforeAll, describe, expect, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
 import { Messenger, type PeerInfo, WebsocketSignalManager } from '@dxos/messaging';
 import { runTestSignalServer, type SignalServerRunner } from '@dxos/signal';
-import { afterAll, afterTest, beforeAll, describe, test } from '@dxos/test';
 
 import { type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
@@ -35,13 +31,15 @@ describe('Signal Integration Test', () => {
   }) => {
     const signalManager = new WebsocketSignalManager([{ server: broker.url() }]);
     await signalManager.open();
-    afterTest(() => signalManager.close());
+    onTestFinished(async () => {
+      await signalManager.close();
+    });
 
     const messenger = new Messenger({
       signalManager,
     });
     messenger.open();
-    afterTest(() => messenger.close());
+    onTestFinished(() => messenger.close());
     await messenger.listen({
       peer,
       onMessage: async (message) => await messageRouter.receiveMessage(message),
@@ -96,7 +94,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toBeAnObjectWith({ accept: true });
+    ).toEqual(expect.objectContaining({ accept: true }));
 
     expect(
       await peerNetworking2.messageRouter.offer({
@@ -108,7 +106,7 @@ describe('Signal Integration Test', () => {
           offer: {},
         },
       }),
-    ).toBeAnObjectWith({ accept: true });
+    ).toEqual(expect.objectContaining({ accept: true }));
 
     {
       const message: SignalMessage = {
@@ -123,9 +121,7 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking1.messageRouter.signal(message);
 
-      await waitForExpect(() => {
-        expect(peerNetworking2.receivedSignals[0]).toBeAnObjectWith(message);
-      });
+      await expect.poll(() => peerNetworking2.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }
 
     {
@@ -141,9 +137,7 @@ describe('Signal Integration Test', () => {
       };
       await peerNetworking2.messageRouter.signal(message);
 
-      await waitForExpect(() => {
-        expect(peerNetworking1.receivedSignals[0]).toBeAnObjectWith(message);
-      });
+      await expect.poll(() => peerNetworking1.receivedSignals[0]).toEqual(expect.objectContaining(message));
     }
   });
 });

package/src/signal/{swarm-messenger.test.ts → swarm-messenger.node.test.ts}

@@ -2,17 +2,13 @@
 // Copyright 2022 DXOS.org
 //
 
-// @dxos/test platform=nodejs
-
-import { expect } from 'earljs';
-import waitForExpect from 'wait-for-expect';
+import { afterAll, beforeAll, beforeEach, describe, expect, test, onTestFinished } from 'vitest';
 
 import { type Awaited } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { Messenger, WebsocketSignalManager } from '@dxos/messaging';
 import { type Answer } from '@dxos/protocols/proto/dxos/mesh/swarm';
 import { runTestSignalServer } from '@dxos/signal';
-import { afterAll, beforeAll, describe, test, afterTest } from '@dxos/test';
 
 import { type OfferMessage, type SignalMessage } from './signal-messenger';
 import { SwarmMessenger } from './swarm-messenger';
@@ -48,7 +44,9 @@ describe('SwarmMessenger', () => {
     const peer = { peerKey: PublicKey.random().toHex() };
     const signalManager = new WebsocketSignalManager([{ server: signalApiUrl }]);
     await signalManager.open();
-    afterTest(() => signalManager.close());
+    onTestFinished(async () => {
+      await signalManager.close();
+    });
 
     const messenger = new Messenger({ signalManager });
     await messenger.listen({
@@ -106,10 +104,8 @@ describe('SwarmMessenger', () => {
     };
     await router2.signal(msg);
 
-    await waitForExpect(() => {
-      expect(received[0]).toBeAnObjectWith(msg);
-    }, 4_000);
-  }).timeout(5_000);
+    await expect.poll(() => received[0]).toEqual(expect.objectContaining(msg));
+  });
 
   test('offer/answer', async () => {
     const {
@@ -139,7 +135,7 @@ describe('SwarmMessenger', () => {
       data: { offer: {} },
     });
     expect(answer.accept).toEqual(true);
-  }).timeout(5_000);
+  });
 
   test('signaling between 3 clients', async () => {
     const received1: SignalMessage[] = [];
@@ -198,9 +194,7 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '1to3' } }, signalBatch: undefined },
     };
     await router1.signal(msg1to3);
-    await waitForExpect(() => {
-      expect(received3[0]).toBeAnObjectWith(msg1to3);
-    }, 4_000);
+    await expect.poll(() => received3[0]).toEqual(expect.objectContaining(msg1to3));
 
     // sending signal from peer2 to peer3.
     const msg2to3: SignalMessage = {
@@ -211,9 +205,7 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '2to3' } }, signalBatch: undefined },
     };
     await router2.signal(msg2to3);
-    await waitForExpect(() => {
-      expect(received3[1]).toBeAnObjectWith(msg2to3);
-    }, 4_000);
+    await expect.poll(() => received3[1]).toEqual(expect.objectContaining(msg2to3));
 
     // sending signal from peer3 to peer1.
     const msg3to1: SignalMessage = {
@@ -224,10 +216,8 @@ describe('SwarmMessenger', () => {
       data: { signal: { payload: { msg: '3to1' } }, signalBatch: undefined },
     };
     await router3.signal(msg3to1);
-    await waitForExpect(() => {
-      expect(received1[0]).toBeAnObjectWith(msg3to1);
-    }, 4_000);
-  }).timeout(5_000);
+    await expect.poll(() => received1[0]).toEqual(expect.objectContaining(msg3to1));
+  });
 
   test('two offers', async () => {
     const {
@@ -273,5 +263,5 @@ describe('SwarmMessenger', () => {
       data: { offer: {} },
     });
     expect(answer2.accept).toEqual(true);
-  }).timeout(5_000);
+  });
 });

package/src/swarm/connection-limiter.test.ts

@@ -1,17 +1,14 @@
 //
 // Copyright 2023 DXOS.org
 //
-import chai, { expect } from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+
+import { describe, expect, test } from 'vitest';
 
 import { asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { describe, test } from '@dxos/test';
 
 import { ConnectionLimiter } from './connection-limiter';
 
-chai.use(chaiAsPromised);
-
 describe('ConnectionLimiter', () => {
   function* setupPeers(
     limiter: ConnectionLimiter,
@@ -37,7 +34,7 @@ describe('ConnectionLimiter', () => {
   test('rejects if done is called', async () => {
     const limiter = new ConnectionLimiter({ maxConcurrentInitConnections: 1 });
     const [first] = setupPeers(limiter);
-    const testPromise = expect(first.connecting()).to.be.rejected;
+    const testPromise = expect(first.connecting()).rejects.toBeInstanceOf(Error);
     first.doneConnecting();
     await testPromise;
   });

package/src/swarm/connection.test.ts

@@ -2,9 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
+import { describe, test } from 'vitest';
+
 import { sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
-import { describe, test } from '@dxos/test';
 
 import { Connection } from './connection';
 import { TestWireProtocol } from '../testing/test-wire-protocol';

package/src/swarm/swarm.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2020 DXOS.org
 //
 
-import { expect } from 'chai';
+import { onTestFinished, describe, expect, test } from 'vitest';
 
 import { asyncTimeout, sleep } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
@@ -13,7 +13,6 @@ import {
   type PeerInfo,
   type SignalManager,
 } from '@dxos/messaging';
-import { afterTest, describe, test } from '@dxos/test';
 import { ComplexSet } from '@dxos/util';
 
 import { ConnectionState } from './connection';
@@ -61,7 +60,7 @@ describe('Swarm', () => {
       initiationDelay,
     );
 
-    afterTest(async () => {
+    onTestFinished(async () => {
       await swarm.destroy();
       await signalManager.close();
     });
@@ -81,7 +80,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2);
-  }).timeout(5_000);
+  });
 
   test('two peers try to originate connections to each other simultaneously', async () => {
     const topic = PublicKey.random();
@@ -93,7 +92,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2);
-  }).timeout(5_000);
+  });
 
   test('with simultaneous connections one of the peers drops initiated connection', async () => {
     const topic = PublicKey.random();
@@ -111,9 +110,9 @@ describe('Swarm', () => {
 
     await connectSwarms(peer1, peer2);
     await asyncTimeout(connectionDisplaced!, 1000);
-  }).timeout(5_000);
+  });
 
-  test('second peer discovered after delay', async () => {
+  test('second peer discovered after delay', { timeout: 10_000 }, async () => {
     const topic = PublicKey.random();
 
     const peer1 = await setupSwarm({ topic });
@@ -126,7 +125,7 @@ describe('Swarm', () => {
     expect(peer2.swarm.connections.length).to.equal(0);
 
     await connectSwarms(peer1, peer2, () => sleep(15));
-  }).timeout(10_000);
+  });
 
   test('connection limiter', async () => {
     // remotePeer1 <--> peer (connectionLimiter: max = 1) <--> remotePeer2

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

@@ -2,13 +2,11 @@
 // Copyright 2021 DXOS.org
 //
 
-import { expect } from 'chai';
-import waitForExpect from 'wait-for-expect';
+import { onTestFinished, expect, test } from 'vitest';
 
 import { asyncTimeout } from '@dxos/async';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { afterTest, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { exchangeMessages, joinSwarm, leaveSwarm, openAndCloseAfterTest } from './utils';
@@ -25,7 +23,7 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     return;
   }
 
-  test('joins swarm, sends messages, and cleanly exits', async () => {
+  test.skip('joins swarm, sends messages, and cleanly exits', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -34,24 +32,24 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
   // TODO(burdon): Test with more peers (configure and test messaging).
-  test('joins swarm with star topology', async () => {
+  test.skip('joins swarm with star topology', async () => {
     const peer1 = testBuilder.createPeer();
-    afterTest(() => peer1.close());
+    onTestFinished(() => peer1.close());
     const peer2 = testBuilder.createPeer();
-    afterTest(() => peer2.close());
+    onTestFinished(() => peer2.close());
     await openAndCloseAfterTest([peer1, peer2]);
 
     const topic = PublicKey.random();
     const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new StarTopology(peer1.peerId)); // NOTE: Same peer.
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
   // TODO(burdon): Fails when trying to reconnect to same topic.
-  test('joins swarm multiple times', async () => {
+  test.skip('joins swarm multiple times', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -75,9 +73,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       await exchangeMessages(swarm1, swarm2);
       await leaveSwarm([peer1, peer2], topic2);
     }
-  }).tag('flaky');
+  });
 
-  test('joins multiple swarms', async () => {
+  test.skip('joins multiple swarms', async () => {
     // TODO(burdon): N peers.
     // TODO(burdon): Merge with test below.
     const peer1 = testBuilder.createPeer();
@@ -87,9 +85,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     const numSwarms = 5;
     const topics = Array.from(Array(numSwarms)).map(() => PublicKey.random());
     expect(topics).to.have.length(numSwarms);
-  }).tag('flaky');
+  });
 
-  test('joins multiple swarms concurrently', async () => {
+  test.skip('joins multiple swarms concurrently', async () => {
     const createSwarm = async () => {
       const topicA = PublicKey.random();
       const peer1a = testBuilder.createPeer();
@@ -109,9 +107,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
       test1.swarm1a.protocol.testConnection(test1.peer2a.peerId),
       test2.swarm1a.protocol.testConnection(test2.peer2a.peerId),
     ]);
-  }).tag('flaky');
+  });
 
-  test('peers reconnect after and error in connection', async () => {
+  test.skip('peers reconnect after and error in connection', async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -131,9 +129,9 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     await exchangeMessages(swarm1, swarm2);
 
     await leaveSwarm([peer1, peer2], topic);
-  }).tag('flaky');
+  });
 
-  test('going offline and back online', async () => {
+  test.skip('going offline and back online', { timeout: 2_000 }, async () => {
     const peer1 = testBuilder.createPeer();
     const peer2 = testBuilder.createPeer();
     await openAndCloseAfterTest([peer1, peer2]);
@@ -158,28 +156,31 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     await peerLeft;
 
     // Wait for peer to be removed from the swarm.
-    await waitForExpect(() => {
-      expect(!!peer2._networkManager.getSwarm(topic)!._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing).to.be
-        .false;
-    }, 1_000);
+    await expect
+      .poll(() => !!peer2._networkManager.getSwarm(topic)!._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing, {
+        timeout: 1_000,
+      })
+      .toBe(false);
 
     await peer1.goOnline();
 
-    await waitForExpect(() => {
-      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 expect
+      .poll(() => peer1._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer2.peerId.toHex() })?.advertizing, {
+        timeout: 2_000,
+      })
+      .toBe(true);
+    await expect
+      .poll(() => peer2._networkManager.getSwarm(topic)?._peers.get({ peerKey: peer1.peerId.toHex() })?.advertizing, {
+        timeout: 2_000,
+      })
+      .toBe(true);
 
     await exchangeMessages(swarm1, swarm2);
     await leaveSwarm([peer1, peer2], topic);
-  })
-    .tag('flaky')
-    .timeout(2_000);
+  });
 
   // TODO(mykola): Fails with large amount of peers ~10.
-  test('many peers and connections', async () => {
+  test.skip('many peers and connections', async () => {
     const numTopics = 2;
     const peersPerTopic = 3;
     const swarmsAllPeersConnected: Promise<any>[] = [];
@@ -207,5 +208,5 @@ export const basicTestSuite = (testBuilder: TestBuilder, runTests = true) => {
     );
 
     await asyncTimeout(Promise.all(swarmsAllPeersConnected), 2_000);
-  }).tag('stress');
+  });
 };

package/src/tests/memory-transport.test.ts

@@ -2,10 +2,10 @@
 // Copyright 2021 DXOS.org
 //
 
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
+import { describe, test } from 'vitest';
 
 import { PublicKey } from '@dxos/keys';
-import { test } from '@dxos/test';
 import { range } from '@dxos/util';
 
 import { basicTestSuite } from './basic-test-suite';
@@ -17,47 +17,45 @@ describe('Memory transport', () => {
   const testBuilder = new TestBuilder();
   basicTestSuite(testBuilder);
 
-  test
-    .skip('load', async () => {
-      const NUM_PAIRS = 100;
-      const NUM_ROUNDS = 10_000;
-      const PACKET_SIZE = 1_000;
-
-      const pairs = await Promise.all(
-        range(NUM_PAIRS).map(async () => {
-          const peer1 = testBuilder.createPeer();
-          const peer2 = testBuilder.createPeer();
-          await openAndCloseAfterTest([peer1, peer2]);
-
-          const topic = PublicKey.random();
-          const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
-
-          return {
-            peer1,
-            peer2,
-            topic,
-            swarm1,
-            swarm2,
-          };
-        }),
-      );
-
-      const message = randomBytes(PACKET_SIZE / 2).toString('hex');
-
-      for (let i = 0; i < NUM_ROUNDS; i++) {
-        // console.log(`Round ${i}/${NUM_ROUNDS}`);
-        await Promise.all(
-          pairs.map(async ({ swarm1, swarm2 }) => {
-            await exchangeMessages(swarm1, swarm2, message);
-          }),
-        );
-      }
-
+  test.skip('load', { timeout: 1_000_000 }, async () => {
+    const NUM_PAIRS = 100;
+    const NUM_ROUNDS = 10_000;
+    const PACKET_SIZE = 1_000;
+
+    const pairs = await Promise.all(
+      range(NUM_PAIRS).map(async () => {
+        const peer1 = testBuilder.createPeer();
+        const peer2 = testBuilder.createPeer();
+        await openAndCloseAfterTest([peer1, peer2]);
+
+        const topic = PublicKey.random();
+        const [swarm1, swarm2] = await joinSwarm([peer1, peer2], topic, () => new FullyConnectedTopology());
+
+        return {
+          peer1,
+          peer2,
+          topic,
+          swarm1,
+          swarm2,
+        };
+      }),
+    );
+
+    const message = randomBytes(PACKET_SIZE / 2).toString('hex');
+
+    for (let i = 0; i < NUM_ROUNDS; i++) {
+      // console.log(`Round ${i}/${NUM_ROUNDS}`);
       await Promise.all(
-        pairs.map(async ({ peer1, peer2, topic }) => {
-          await leaveSwarm([peer1, peer2], topic);
+        pairs.map(async ({ swarm1, swarm2 }) => {
+          await exchangeMessages(swarm1, swarm2, message);
         }),
       );
-    })
-    .timeout(1_000_000);
+    }
+
+    await Promise.all(
+      pairs.map(async ({ peer1, peer2, topic }) => {
+        await leaveSwarm([peer1, peer2], topic);
+      }),
+    );
+  });
 });