feat: nwaku interop test for peer-exchange (#1129)

* handle a breaking edge case
- changes interval from static to increasing
- handles an edge case which resulted in unwanted return
from a function

* modularise code & make defaults configurable
- breaks the backoff code into a separate function
- makes default values configurable
- improve interval handling

* clean code for checking peer in peerStore

* address comments

* rename `backoff` to `abort`

* add locally run nwaku interop test for peer-exchange

* replace `--listen-address` with `--nat:extip`

* address improvements

.cspell.json

@@ -11,6 +11,7 @@
     "backoffs",
     "bitauth",
     "bitjson",
+    "extip",
     "bufbuild",
     "chainsafe",
     "cimg",

packages/tests/src/nwaku.ts

@@ -57,6 +57,7 @@ export interface Args {
   rpcPort?: number;
   websocketPort?: number;
   discv5BootstrapNode?: string;
+  discv5UdpPort?: number;
 }
 
 export enum LogLevel {
@@ -146,7 +147,7 @@ export class Nwaku {
     const startPort = Math.floor(Math.random() * (65535 - 1025) + 1025);
 
     const ports: number[] = await new Promise((resolve, reject) => {
-      portfinder.getPorts(3, { port: startPort }, (err, ports) => {
+      portfinder.getPorts(4, { port: startPort }, (err, ports) => {
         if (err) reject(err);
         resolve(ports);
       });
@@ -161,6 +162,7 @@ export class Nwaku {
         tcpPort: ports[1],
         rpcPort: this.rpcPort,
         websocketPort: ports[2],
+        ...(args?.peerExchange && { discv5UdpPort: ports[3] }),
       },
       args
     );
@@ -171,6 +173,9 @@ export class Nwaku {
 
     const argsArray = argsToArray(mergedArgs);
 
+    const natExtIp = "--nat:extip:127.0.0.1";
+    argsArray.push(natExtIp);
+
     if (WAKU_SERVICE_NODE_PARAMS) {
       argsArray.push(WAKU_SERVICE_NODE_PARAMS);
     }

packages/tests/tests/peer_exchange.node.spec.ts

@@ -11,6 +11,8 @@ import { wakuPeerExchangeDiscovery } from "@waku/peer-exchange";
 import { expect } from "chai";
 
 import { delay } from "../src/delay.js";
+import { makeLogFileName } from "../src/log_file.js";
+import { Nwaku } from "../src/nwaku.js";
 
 describe("Peer Exchange", () => {
   let waku: LightNode;
@@ -84,4 +86,84 @@ describe("Peer Exchange", () => {
 
     expect(receivedCallback).to.be.true;
   });
+
+  describe("Locally run nodes", () => {
+    let waku: LightNode;
+    let nwaku1: Nwaku;
+    let nwaku2: Nwaku;
+
+    beforeEach(async function () {
+      nwaku1 = new Nwaku(makeLogFileName(this) + "1");
+      nwaku2 = new Nwaku(makeLogFileName(this) + "2");
+    });
+
+    afterEach(async function () {
+      !!nwaku1 && nwaku1.stop();
+      !!nwaku2 && nwaku2.stop();
+      !!waku && waku.stop().catch((e) => console.log("Waku failed to stop", e));
+    });
+
+    it("nwaku interop", async function () {
+      this.timeout(25_000);
+
+      await nwaku1.start({
+        discv5Discovery: true,
+        peerExchange: true,
+      });
+
+      const enr = (await nwaku1.info()).enrUri;
+
+      await nwaku2.start({
+        discv5Discovery: true,
+        peerExchange: true,
+        discv5BootstrapNode: enr,
+      });
+
+      const nwaku1Ma = await nwaku1.getMultiaddrWithId();
+      const nwaku2Ma = await nwaku2.getMultiaddrWithId();
+
+      waku = await createLightNode();
+      await waku.start();
+      await waku.dial(nwaku2Ma);
+
+      await waitForRemotePeer(waku, [Protocols.PeerExchange]);
+
+      await nwaku2.waitForLog("Discovered px peers via discv5", 1);
+
+      let receivedCallback = false;
+
+      const numPeersToRequest = 1;
+      const callback = async (
+        response: PeerExchangeResponse
+      ): Promise<void> => {
+        const doesMultiaddrExist = response.peerInfos.find(
+          (peerInfo) =>
+            peerInfo.ENR?.getFullMultiaddrs()?.find((multiaddr) =>
+              multiaddr.equals(nwaku1Ma)
+            ) !== undefined
+        );
+
+        expect(response.peerInfos.length).to.be.greaterThan(0);
+        expect(response.peerInfos.length).to.be.lessThanOrEqual(
+          numPeersToRequest
+        );
+        expect(response.peerInfos[0].ENR).to.not.be.null;
+
+        expect(doesMultiaddrExist).to.be.equal(true);
+
+        expect(waku.libp2p.peerStore.has(await nwaku2.getPeerId())).to.be.true;
+
+        receivedCallback = true;
+      };
+
+      await waku.peerExchange.query(
+        {
+          numPeers: numPeersToRequest,
+        },
+        callback
+      );
+
+      expect(receivedCallback).to.be.true;
+    });
+  });
 });