feat(discv5): advertise custom multiaddresses (#1512)

* feat(discv5): allow custom multiaddr advertisement in discv5

feat(discv5): allow custom multiaddr advertisement in discv5

feat(discv5): move discv5 setup from wakunode2 to waku_node

fix(waku_node): def param

test(discv5): test for ext multiaddr

fix(discv5): address comments

fix(discv5): address comments

fix(wakunode2): discoveryconfig in var before init

fix(discv5): pass multiaddr to discv5 directly

fix(discv5): make multiaddrs optional

fix(test): discv5 init

fix(discv5): split discv5 mounting from waku_node

chore(discv5): s/WakuAddressMetadata/WakuNodeAddrMeta/g

* fix(waku_node): 1.25 max conns

* fix(discv5): s/WakuNodeAddrMeta/NetConfig/g

* fix(discv5): address reviews

* fix(discv5): smaller try-catches

* fix(discv5): missing arg

* fix: compile error

apps/wakunode2/wakunode2.nim

@@ -278,61 +278,77 @@ proc initNode(conf: WakuNodeConf,
 
   let pStorage = if peerStore.isNone(): nil
                  else: peerStore.get()
+
+  let rng = crypto.newRng()
+  # Wrap in none because NetConfig does not have a default constructor
+  # TODO: We could change bindIp in NetConfig to be something less restrictive than ValidIpAddress,
+  # which doesn't allow default construction
+  var netConfigOpt = none(NetConfig)
+
   try:
-    node = WakuNode.new(nodekey,
+    netConfigOpt = some(NetConfig.init(
-                        conf.listenAddress, Port(uint16(conf.tcpPort) + conf.portsShift),
+      bindIp = conf.listenAddress,
-                        extIp, extPort,
+      bindPort = Port(uint16(conf.tcpPort) + conf.portsShift),
-                        extMultiAddrs,
+      extIp = extIp,
-                        pStorage,
+      extPort = extPort,
-                        conf.maxConnections.int,
+      extMultiAddrs = extMultiAddrs,
-                        Port(uint16(conf.websocketPort) + conf.portsShift),
+      wsBindPort = Port(uint16(conf.websocketPort) + conf.portsShift),
-                        conf.websocketSupport,
+      wsEnabled = conf.websocketSupport,
-                        conf.websocketSecureSupport,
+      wssEnabled = conf.websocketSecureSupport,
-                        conf.websocketSecureKeyPath,
+      dns4DomainName = dns4DomainName,
-                        conf.websocketSecureCertPath,
+      discv5UdpPort = discv5UdpPort,
-                        some(wakuFlags),
+      wakuFlags = some(wakuFlags),
-                        dnsResolver,
+    ))
-                        conf.relayPeerExchange, # We send our own signed peer record when peer exchange enabled
-                        dns4DomainName,
-                        discv5UdpPort,
-                        some(conf.agentString),
-                        conf.peerStoreCapacity,
-                        rng)
   except:
-    return err("failed to create waku node instance: " & getCurrentExceptionMsg())
+    return err("failed to create net config instance: " & getCurrentExceptionMsg())
+
+  let netConfig = netConfigOpt.get()
+  var wakuDiscv5 = none(WakuDiscoveryV5)
 
   if conf.discv5Discovery:
-    let
+    let dynamicBootstrapEnrs = dynamicBootstrapNodes
-      discoveryConfig = DiscoveryConfig.init(
+                                .filterIt(it.hasUdpPort())
-        conf.discv5TableIpLimit, conf.discv5BucketIpLimit, conf.discv5BitsPerHop)
+                                .mapIt(it.enr.get())
-
-    # select dynamic bootstrap nodes that have an ENR containing a udp port.
-    # Discv5 only supports UDP https://github.com/ethereum/devp2p/blob/master/discv5/discv5-theory.md)
     var discv5BootstrapEnrs: seq[enr.Record]
-    for n in dynamicBootstrapNodes:
-      if n.enr.isSome():
-        let
-          enr = n.enr.get()
-          tenrRes = enr.toTypedRecord()
-        if tenrRes.isOk() and (tenrRes.get().udp.isSome() or tenrRes.get().udp6.isSome()):
-          discv5BootstrapEnrs.add(enr)
-
     # parse enrURIs from the configuration and add the resulting ENRs to the discv5BootstrapEnrs seq
     for enrUri in conf.discv5BootstrapNodes:
       addBootstrapNode(enrUri, discv5BootstrapEnrs)
-
+    discv5BootstrapEnrs.add(dynamicBootstrapEnrs)
-    node.wakuDiscv5 = WakuDiscoveryV5.new(
+    let discv5Config = DiscoveryConfig.init(conf.discv5TableIpLimit,
-      extIP, extPort, discv5UdpPort,
+                                            conf.discv5BucketIpLimit,
-      conf.listenAddress,
+                                            conf.discv5BitsPerHop)
-      discv5UdpPort.get(),
+    try:
-      discv5BootstrapEnrs,
+      wakuDiscv5 = some(WakuDiscoveryV5.new(
-      conf.discv5EnrAutoUpdate,
+        extIp = netConfig.extIp,
-      keys.PrivateKey(nodekey.skkey),
+        extTcpPort = netConfig.extPort,
-      wakuFlags,
+        extUdpPort = netConfig.discv5UdpPort,
-      [], # Empty enr fields, for now
+        bindIp = netConfig.bindIp,
-      node.rng,
+        discv5UdpPort = netConfig.discv5UdpPort.get(),
-      discoveryConfig
+        bootstrapEnrs = discv5BootstrapEnrs,
-    )
+        enrAutoUpdate = conf.discv5EnrAutoUpdate,
+        privateKey = keys.PrivateKey(nodekey.skkey),
+        flags = netConfig.wakuFlags.get(),
+        multiaddrs = netConfig.enrMultiaddrs,
+        rng = rng,
+        discv5Config = discv5Config,
+      ))
+    except:
+      return err("failed to create waku discv5 instance: " & getCurrentExceptionMsg())
+  try:
+    node = WakuNode.new(nodekey = nodekey,
+                        netConfig = netConfig,
+                        peerStorage = pStorage,
+                        maxConnections = conf.maxConnections.int,
+                        secureKey = conf.websocketSecureKeyPath,
+                        secureCert = conf.websocketSecureCertPath,
+                        nameResolver = dnsResolver,
+                        sendSignedPeerRecord = conf.relayPeerExchange, # We send our own signed peer record when peer exchange enabled
+                        wakuDiscv5 = wakuDiscv5,
+                        agentString = some(conf.agentString),
+                        peerStoreCapacity = conf.peerStoreCapacity,
+                        rng = rng)
+  except:
+    return err("failed to create waku node instance: " & getCurrentExceptionMsg())
 
   ok(node)
 

examples/v2/publisher.nim

@@ -48,7 +48,6 @@ proc setupAndPublish(rng: ref HmacDrbgContext) {.async.} =
         bootstrapNodes = bootstrapNodes,
         privateKey = keys.PrivateKey(nodeKey.skkey),
         flags = flags,
-        enrFields = [],
         rng = node.rng)
 
     await node.start()

examples/v2/subscriber.nim

@@ -44,7 +44,6 @@ proc setupAndSubscribe(rng: ref HmacDrbgContext) {.async.} =
         bootstrapNodes = bootstrapNodes,
         privateKey = keys.PrivateKey(nodeKey.skkey),
         flags = flags,
-        enrFields = [],
         rng = node.rng)
 
     await node.start()

tests/v2/test_enr_utils.nim

@@ -50,7 +50,7 @@ procSuite "ENR utils":
                      MultiAddress.init("/ip4/127.0.0.1/tcp/443/wss")[]]
 
     let
-      record = initEnr(enrKey, some(enrIp),
+      record = enr.Record.init(enrKey, some(enrIp),
                        some(enrTcpPort), some(enrUdpPort),
                        some(wakuFlags),
                        multiaddrs)
@@ -81,7 +81,7 @@ procSuite "ENR utils":
       multiaddrs = @[MultiAddress.init("/ip4/127.0.0.1/tcp/443/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr31iDQpSN5Qa882BCjjwgrD")[]]
 
     let
-      record = initEnr(enrKey, some(enrIp),
+      record = enr.Record.init(enrKey, some(enrIp),
                        some(enrTcpPort), some(enrUdpPort),
                        none(WakuEnrBitfield),
                        multiaddrs)
@@ -133,11 +133,11 @@ procSuite "ENR utils":
       enrKey = wakuenr.crypto.PrivateKey.random(Secp256k1, rng[])[]
       multiaddrs = @[MultiAddress.init("/ip4/127.0.0.1/tcp/442/ws")[]]
 
-      # TODO: Refactor initEnr, provide enums as inputs initEnr(capabilites=[Store,Filter])
+      # TODO: Refactor enr.Record.init, provide enums as inputs enr.Record.init(capabilites=[Store,Filter])
       # TODO: safer than a util function and directly using the bits
       # test all flag combinations 2^4 = 16 (b0000-b1111)
       records = toSeq(0b0000_0000'u8..0b0000_1111'u8)
-                        .mapIt(initEnr(enrKey,
+                        .mapIt(enr.Record.init(enrKey,
                                        some(enrIp),
                                        some(enrTcpPort),
                                        some(enrUdpPort),
@@ -178,7 +178,7 @@ procSuite "ENR utils":
                   0b0000_1001'u8,
                   0b0000_1110'u8,
                   0b0000_1000'u8,]
-                  .mapIt(initEnr(enrKey,
+                  .mapIt(enr.Record.init(enrKey,
                                          some(enrIp),
                                          some(enrTcpPort),
                                          some(enrUdpPort),

tests/v2/test_waku_discv5.nim

@@ -2,6 +2,7 @@
 
 import
   chronos,
+  chronicles,
   testutils/unittests,
   stew/byteutils,
   stew/shims/net,
@@ -56,7 +57,7 @@ procSuite "Waku Discovery v5":
         false,
         keys.PrivateKey(nodeKey1.skkey),
         flags,
-        [], # Empty enr fields, for now
+        newSeq[MultiAddress](), # Empty multiaddr fields, for now
         node1.rng
       )
 
@@ -68,7 +69,7 @@ procSuite "Waku Discovery v5":
         false,
         keys.PrivateKey(nodeKey2.skkey),
         flags,
-        [], # Empty enr fields, for now
+        newSeq[MultiAddress](), # Empty multiaddr fields, for now
         node2.rng
       )
 
@@ -80,7 +81,7 @@ procSuite "Waku Discovery v5":
         false,
         keys.PrivateKey(nodeKey3.skkey),
         flags,
-        [], # Empty enr fields, for now
+        newSeq[MultiAddress](), # Empty multiaddr fields, for now
         node3.rng
       )
 
@@ -119,3 +120,76 @@ procSuite "Waku Discovery v5":
     #   (await completionFut.withTimeout(6.seconds)) == true
 
     await allFutures([node1.stop(), node2.stop(), node3.stop()])
+
+  asyncTest "Custom multiaddresses are advertised correctly":
+    let
+      bindIp = ValidIpAddress.init("0.0.0.0")
+      extIp = ValidIpAddress.init("127.0.0.1")
+      expectedMultiAddr = MultiAddress.init("/ip4/200.200.200.200/tcp/9000/wss").tryGet()
+
+      flags = initWakuFlags(lightpush = false,
+                            filter = false,
+                            store = false,
+                            relay = true)
+
+      nodeTcpPort1 = Port(9010)
+      nodeUdpPort1 = Port(9012)
+      node1Key = generateKey()
+      node1NetConfig = NetConfig.init(bindIp = bindIp,
+                                      extIp = some(extIp),
+                                      extPort = some(nodeTcpPort1),
+                                      bindPort = nodeTcpPort1,
+                                      extmultiAddrs = @[expectedMultiAddr],
+                                      wakuFlags = some(flags),
+                                      discv5UdpPort = some(nodeUdpPort1))
+      node1discV5 = WakuDiscoveryV5.new(extIp = node1NetConfig.extIp,
+                                        extTcpPort = node1NetConfig.extPort,
+                                        extUdpPort = node1NetConfig.discv5UdpPort,
+                                        bindIp = node1NetConfig.bindIp,
+                                        discv5UdpPort = node1NetConfig.discv5UdpPort.get(),
+                                        privateKey = keys.PrivateKey(node1Key.skkey),
+                                        multiaddrs = node1NetConfig.enrMultiaddrs,
+                                        flags = node1NetConfig.wakuFlags.get(),
+                                        rng = rng)
+      node1 = WakuNode.new(nodekey = node1Key,
+                           netConfig = node1NetConfig,
+                           wakuDiscv5 = some(node1discV5),
+                           rng = rng)
+
+
+      nodeTcpPort2 = Port(9014)
+      nodeUdpPort2 = Port(9016)
+      node2Key = generateKey()
+      node2NetConfig = NetConfig.init(bindIp = bindIp,
+                                      extIp = some(extIp),
+                                      extPort = some(nodeTcpPort2),
+                                      bindPort = nodeTcpPort2,
+                                      wakuFlags = some(flags),
+                                      discv5UdpPort = some(nodeUdpPort2))
+      node2discV5 = WakuDiscoveryV5.new(extIp = node2NetConfig.extIp,
+                                        extTcpPort = node2NetConfig.extPort,
+                                        extUdpPort = node2NetConfig.discv5UdpPort,
+                                        bindIp = node2NetConfig.bindIp,
+                                        discv5UdpPort = node2NetConfig.discv5UdpPort.get(),
+                                        bootstrapEnrs = @[node1.wakuDiscv5.protocol.localNode.record],
+                                        privateKey = keys.PrivateKey(node2Key.skkey),
+                                        flags = node2NetConfig.wakuFlags.get(),
+                                        rng = rng)
+      node2 = WakuNode.new(nodeKey = node2Key,
+                           netConfig = node2NetConfig,
+                           wakuDiscv5 = some(node2discV5))
+
+    await allFutures([node1.start(), node2.start()])
+
+    await allFutures([node1.startDiscv5(), node2.startDiscv5()])
+
+    await sleepAsync(3000.millis) # Give the algorithm some time to work its magic
+
+    let node1Enr = node2.wakuDiscv5.protocol.routingTable.buckets[0].nodes[0].record
+    let multiaddrs = node1Enr.get(MULTIADDR_ENR_FIELD, seq[byte])[].toMultiAddresses()
+
+    check:
+      node1.wakuDiscv5.protocol.nodesDiscovered > 0
+      node2.wakuDiscv5.protocol.nodesDiscovered > 0
+      multiaddrs.contains(expectedMultiAddr)
+

tests/v2/test_waku_peer_exchange.nim

@@ -103,7 +103,7 @@ procSuite "Waku Peer Exchange":
         false,
         keys.PrivateKey(nodeKey1.skkey),
         flags,
-        [], # Empty enr fields, for now
+        newSeq[MultiAddress](), # Empty multiaddr fields, for now
         node1.rng
       )
 
@@ -115,7 +115,7 @@ procSuite "Waku Peer Exchange":
         false,
         keys.PrivateKey(nodeKey2.skkey),
         flags,
-        [], # Empty enr fields, for now
+        newSeq[MultiAddress](), # Empty multiaddr fields, for now
         node2.rng
       )
 

waku/v2/node/discv5/waku_discv5.nim

@@ -112,18 +112,20 @@ proc new*(T: type WakuDiscoveryV5,
           extTcpPort, extUdpPort: Option[Port],
           bindIP: ValidIpAddress,
           discv5UdpPort: Port,
-          bootstrapEnrs: seq[enr.Record],
+          bootstrapEnrs = newSeq[enr.Record](),
           enrAutoUpdate = false,
           privateKey: keys.PrivateKey,
           flags: WakuEnrBitfield,
-          enrFields: openArray[(string, seq[byte])],
+          multiaddrs = newSeq[MultiAddress](),
           rng: ref HmacDrbgContext,
           discv5Config: protocol.DiscoveryConfig = protocol.defaultDiscoveryConfig): T =
   ## TODO: consider loading from a configurable bootstrap file
 
   ## We always add the waku field as specified
   var enrInitFields = @[(WAKU_ENR_FIELD, @[flags.byte])]
-  enrInitFields.add(enrFields)
+
+  ## Add multiaddresses to ENR
+  enrInitFields.add((MULTIADDR_ENR_FIELD, multiaddrs.getRawField()))
 
   let protocol = newProtocol(
     privateKey,
@@ -148,7 +150,7 @@ proc new*(T: type WakuDiscoveryV5,
           enrAutoUpdate = false,
           privateKey: keys.PrivateKey,
           flags: WakuEnrBitfield,
-          enrFields: openArray[(string, seq[byte])],
+          multiaddrs = newSeq[MultiAddress](),
           rng: ref HmacDrbgContext,
           discv5Config: protocol.DiscoveryConfig = protocol.defaultDiscoveryConfig): T =
 
@@ -164,7 +166,7 @@ proc new*(T: type WakuDiscoveryV5,
         enrAutoUpdate,
         privateKey,
         flags,
-        enrFields,
+        multiaddrs,
         rng,
         discv5Config
       )

waku/v2/node/waku_node.nim

@@ -131,38 +131,47 @@ template wsFlag(wssEnabled: bool): MultiAddress =
   if wssEnabled: MultiAddress.init("/wss").tryGet()
   else: MultiAddress.init("/ws").tryGet()
 
-proc new*(T: type WakuNode,
+type NetConfig* = object
-          nodeKey: crypto.PrivateKey,
+  hostAddress*: MultiAddress
+  wsHostAddress*: Option[MultiAddress]
+  hostExtAddress*: Option[MultiAddress]
+  wsExtAddress*: Option[MultiAddress]
+  wssEnabled*: bool
+  extIp*: Option[ValidIpAddress]
+  extPort*: Option[Port]
+  dns4DomainName*: Option[string]
+  announcedAddresses*: seq[MultiAddress]
+  extMultiAddrs*: seq[MultiAddress]
+  enrMultiAddrs*: seq[MultiAddress]
+  enrIp*: Option[ValidIpAddress]
+  enrPort*: Option[Port]
+  discv5UdpPort*: Option[Port]
+  wakuFlags*: Option[WakuEnrBitfield]
+  bindIp*: ValidIpAddress
+  bindPort*: Port
+
+proc init*(
+  T: type NetConfig,
   bindIp: ValidIpAddress,
   bindPort: Port,
   extIp = none(ValidIpAddress),
   extPort = none(Port),
   extMultiAddrs = newSeq[MultiAddress](),
-          peerStorage: PeerStorage = nil,
-          maxConnections = builders.MaxConnections,
   wsBindPort: Port = (Port)8000,
   wsEnabled: bool = false,
   wssEnabled: bool = false,
-          secureKey: string = "",
-          secureCert: string = "",
-          wakuFlags = none(WakuEnrBitfield),
-          nameResolver: NameResolver = nil,
-          sendSignedPeerRecord = false,
   dns4DomainName = none(string),
   discv5UdpPort = none(Port),
-          agentString = none(string),    # defaults to nim-libp2p version
+  wakuFlags = none(WakuEnrBitfield)
-          peerStoreCapacity = none(int), # defaults to 1.25 maxConnections
+): T {.raises: [LPError]} =
-          # TODO: make this argument required after tests are updated
-          rng: ref HmacDrbgContext = crypto.newRng()
-          ): T {.raises: [Defect, LPError, IOError, TLSStreamProtocolError].} =
-  ## Creates a Waku Node instance.
-
   ## Initialize addresses
   let
     # Bind addresses
     hostAddress = ip4TcpEndPoint(bindIp, bindPort)
     wsHostAddress = if wsEnabled or wssEnabled: some(ip4TcpEndPoint(bindIp, wsbindPort) & wsFlag(wssEnabled))
                     else: none(MultiAddress)
+    enrIp = if extIp.isSome(): extIp else: some(bindIp)
+    enrPort = if extPort.isSome(): extPort else: some(bindPort)
 
   # Setup external addresses, if available
   var
@@ -198,25 +207,48 @@ proc new*(T: type WakuNode,
   elif wsHostAddress.isSome():
     announcedAddresses.add(wsHostAddress.get())
 
-  ## Initialize peer
   let
-    enrIp = if extIp.isSome(): extIp
-            else: some(bindIp)
-    enrTcpPort = if extPort.isSome(): extPort
-                 else: some(bindPort)
     # enrMultiaddrs are just addresses which cannot be represented in ENR, as described in
     # https://rfc.vac.dev/spec/31/#many-connection-types
     enrMultiaddrs = announcedAddresses.filterIt(it.hasProtocol("dns4") or
                                                 it.hasProtocol("dns6") or
                                                 it.hasProtocol("ws") or
                                                 it.hasProtocol("wss"))
-    enr = initEnr(nodeKey,
-                  enrIp,
-                  enrTcpPort,
-                  discv5UdpPort,
-                  wakuFlags,
-                  enrMultiaddrs)
 
+  return NetConfig(
+    hostAddress: hostAddress,
+    wsHostAddress: wsHostAddress,
+    hostExtAddress: hostExtAddress,
+    wsExtAddress: wsExtAddress,
+    extIp: extIp,
+    extPort: extPort,
+    wssEnabled: wssEnabled,
+    dns4DomainName: dns4DomainName,
+    announcedAddresses: announcedAddresses,
+    extMultiAddrs: extMultiAddrs,
+    enrMultiaddrs: enrMultiaddrs,
+    enrIp: enrIp,
+    enrPort: enrPort,
+    discv5UdpPort: discv5UdpPort,
+    bindIp: bindIp,
+    bindPort: bindPort,
+    wakuFlags: wakuFlags)
+
+
+proc getEnr*(netConfig: NetConfig,
+             wakuDiscV5 = none(WakuDiscoveryV5),
+             nodeKey: crypto.PrivateKey): enr.Record =
+  if wakuDiscV5.isSome():
+    return wakuDiscV5.get().protocol.getRecord()
+
+  return enr.Record.init(nodekey,
+                         netConfig.enrIp,
+                         netConfig.enrPort,
+                         netConfig.discv5UdpPort,
+                         netConfig.wakuFlags,
+                         netConfig.enrMultiaddrs)
+
+proc getAutonatService*(rng = crypto.newRng()): AutonatService =
   ## AutonatService request other peers to dial us back
   ## flagging us as Reachable or NotReachable.
   ## minConfidence is used as threshold to determine the state.
@@ -237,36 +269,107 @@ proc new*(T: type WakuNode,
 
   autonatService.statusAndConfidenceHandler(statusAndConfidenceHandler)
 
-  info "Initializing networking", addrs=announcedAddresses
+  return autonatService
+
+## retain old signature, but deprecate it
+proc new*(T: type WakuNode,
+          nodeKey: crypto.PrivateKey,
+          bindIp: ValidIpAddress,
+          bindPort: Port,
+          extIp = none(ValidIpAddress),
+          extPort = none(Port),
+          extMultiAddrs = newSeq[MultiAddress](),
+          peerStorage: PeerStorage = nil,
+          maxConnections = builders.MaxConnections,
+          wsBindPort: Port = (Port)8000,
+          wsEnabled: bool = false,
+          wssEnabled: bool = false,
+          secureKey: string = "",
+          secureCert: string = "",
+          wakuFlags = none(WakuEnrBitfield),
+          nameResolver: NameResolver = nil,
+          sendSignedPeerRecord = false,
+          dns4DomainName = none(string),
+          discv5UdpPort = none(Port),
+          wakuDiscv5 = none(WakuDiscoveryV5),
+          agentString = none(string),    # defaults to nim-libp2p version
+          peerStoreCapacity = none(int), # defaults to 1.25 maxConnections
+          # TODO: make this argument required after tests are updated
+          rng: ref HmacDrbgContext = crypto.newRng()
+          ): T {.raises: [Defect, LPError, IOError, TLSStreamProtocolError], deprecated: "Use NetConfig variant".} =
+  let netConfig = NetConfig.init(
+    bindIp = bindIp,
+    bindPort = bindPort,
+    extIp = extIp,
+    extPort = extPort,
+    extMultiAddrs = extMultiAddrs,
+    wsBindPort = wsBindPort,
+    wsEnabled = wsEnabled,
+    wssEnabled = wssEnabled,
+    wakuFlags = wakuFlags,
+    dns4DomainName = dns4DomainName,
+    discv5UdpPort = discv5UdpPort,
+  )
+
+  return WakuNode.new(
+    nodeKey = nodeKey,
+    netConfig = netConfig,
+    peerStorage = peerStorage,
+    maxConnections = maxConnections,
+    secureKey = secureKey,
+    secureCert = secureCert,
+    nameResolver = nameResolver,
+    sendSignedPeerRecord = sendSignedPeerRecord,
+    wakuDiscv5 = wakuDiscv5,
+    agentString = agentString,
+    peerStoreCapacity = peerStoreCapacity,
+  )
+
+proc new*(T: type WakuNode,
+          nodeKey: crypto.PrivateKey,
+          netConfig: NetConfig,
+          peerStorage: PeerStorage = nil,
+          maxConnections = builders.MaxConnections,
+          secureKey: string = "",
+          secureCert: string = "",
+          nameResolver: NameResolver = nil,
+          sendSignedPeerRecord = false,
+          wakuDiscv5 = none(WakuDiscoveryV5),
+          agentString = none(string),    # defaults to nim-libp2p version
+          peerStoreCapacity = none(int), # defaults to 1.25 maxConnections
+          # TODO: make this argument required after tests are updated
+          rng: ref HmacDrbgContext = crypto.newRng()
+          ): T {.raises: [Defect, LPError, IOError, TLSStreamProtocolError].} =
+  ## Creates a Waku Node instance.
+
+  info "Initializing networking", addrs=netConfig.announcedAddresses
 
   let switch = newWakuSwitch(
     some(nodekey),
-    hostAddress,
+    address = netConfig.hostAddress,
-    wsHostAddress,
+    wsAddress = netConfig.wsHostAddress,
     transportFlags = {ServerFlags.ReuseAddr},
     rng = rng,
     maxConnections = maxConnections,
-    wssEnabled = wssEnabled,
+    wssEnabled = netConfig.wssEnabled,
     secureKeyPath = secureKey,
     secureCertPath = secureCert,
     nameResolver = nameResolver,
     sendSignedPeerRecord = sendSignedPeerRecord,
     agentString = agentString,
     peerStoreCapacity = peerStoreCapacity,
-    services = @[Service(autonatservice)],
+    services = @[Service(getAutonatService(rng))],
   )
 
-  let wakuNode = WakuNode(
+  return WakuNode(
     peerManager: PeerManager.new(switch, peerStorage),
     switch: switch,
     rng: rng,
-    enr: enr,
+    enr: netConfig.getEnr(wakuDiscv5, nodekey),
-    announcedAddresses: announcedAddresses
+    announcedAddresses: netConfig.announcedAddresses,
+    wakuDiscv5: if wakuDiscV5.isSome(): wakuDiscV5.get() else: nil,
   )
 
-  return wakuNode
-
-
 proc peerInfo*(node: WakuNode): PeerInfo =
   node.switch.peerInfo
 

waku/v2/utils/peers.nim

@@ -182,3 +182,18 @@ proc hasProtocol*(ma: MultiAddress, proto: string): bool =
     if p == MultiCodec.codec(proto):
       return true
   return false
+
+func hasUdpPort*(peer: RemotePeerInfo): bool =
+  if peer.enr.isNone():
+   return false
+
+  let
+    enr = peer.enr.get()
+    typedEnrRes = enr.toTypedRecord()
+
+  if typedEnrRes.isErr():
+    return false
+
+  let typedEnr = typedEnrRes.get()
+  typedEnr.udp.isSome() or typedEnr.udp6.isSome()
+

waku/v2/utils/wakuenr.nim

@@ -34,10 +34,7 @@ type
     Filter = 2,
     Lightpush = 3,
 
-func toFieldPair(multiaddrs: seq[MultiAddress]): FieldPair =
+func getRawField*(multiaddrs: seq[MultiAddress]): seq[byte] =
-  ## Converts a seq of multiaddrs to a `multiaddrs` ENR
-  ## field pair according to https://rfc.vac.dev/spec/31/
-  
   var fieldRaw: seq[byte]
 
   for multiaddr in multiaddrs:
@@ -49,6 +46,13 @@ func toFieldPair(multiaddrs: seq[MultiAddress]): FieldPair =
 
     fieldRaw.add(concat(@maSize, maRaw))
 
+  return fieldRaw
+
+func toFieldPair*(multiaddrs: seq[MultiAddress]): FieldPair =
+  ## Converts a seq of multiaddrs to a `multiaddrs` ENR
+  ## field pair according to https://rfc.vac.dev/spec/31/
+  let fieldRaw = multiaddrs.getRawField()
+
   return toFieldPair(MULTIADDR_ENR_FIELD, fieldRaw)
 
 func stripPeerId(multiaddr: MultiAddress): MultiAddress =
@@ -61,7 +65,7 @@ func stripPeerId(multiaddr: MultiAddress): MultiAddress =
 
   return cleanAddr
 
-func stripPeerIds(multiaddrs: seq[MultiAddress]): seq[MultiAddress] =
+func stripPeerIds*(multiaddrs: seq[MultiAddress]): seq[MultiAddress] =
   var cleanAddrs: seq[MultiAddress]
 
   for multiaddr in multiaddrs:
@@ -101,8 +105,8 @@ func initWakuFlags*(lightpush, filter, store, relay: bool): WakuEnrBitfield =
 
   # TODO: With the changes in this PR, this can be refactored? Using the enum?
   # Perhaps refactor to:
-    # WaKuEnr.initEnr(..., capabilities=[Store, Lightpush])
+    # WaKuEnr.enr.Record.init(..., capabilities=[Store, Lightpush])
-    # WaKuEnr.initEnr(..., capabilities=[Store, Lightpush, Relay, Filter])
+    # WaKuEnr.enr.Record.init(..., capabilities=[Store, Lightpush, Relay, Filter])
 
   # Safer also since we dont inject WakuEnrBitfield, and we let this package
   # handle the bits according to the capabilities
@@ -141,11 +145,12 @@ func toMultiAddresses*(multiaddrsField: seq[byte]): seq[MultiAddress] =
 
   return multiaddrs
 
-func initEnr*(privateKey: crypto.PrivateKey,
+func init*(T: type enr.Record,
+           privateKey: crypto.PrivateKey,
            enrIp: Option[ValidIpAddress],
            enrTcpPort, enrUdpPort: Option[Port],
            wakuFlags = none(WakuEnrBitfield),
-              multiaddrs: seq[MultiAddress] = @[]): enr.Record =
+           multiaddrs: seq[MultiAddress] = @[]): T =
 
   assert privateKey.scheme == PKScheme.Secp256k1