waku-org
/
nwaku
mirror of https://github.com/waku-org/nwaku.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Aaryamann Challani 2023-02-07 18:36:50 +05:30 committed by GitHub
parent 7f2ea1caeb
commit 9ddf0fe1e2
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 379 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
apps/wakunode2/wakunode2.nim
View File

@ -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,
conf.listenAddress, Port(uint16(conf.tcpPort) + conf.portsShift),
extIp, extPort,
extMultiAddrs,
pStorage,
conf.maxConnections.int,
Port(uint16(conf.websocketPort) + conf.portsShift),
conf.websocketSupport,
conf.websocketSecureSupport,
conf.websocketSecureKeyPath,
conf.websocketSecureCertPath,
some(wakuFlags),
dnsResolver,
conf.relayPeerExchange, # We send our own signed peer record when peer exchange enabled
dns4DomainName,
discv5UdpPort,
some(conf.agentString),
conf.peerStoreCapacity,
rng)
netConfigOpt = some(NetConfig.init(
bindIp = conf.listenAddress,
bindPort = Port(uint16(conf.tcpPort) + conf.portsShift),
extIp = extIp,
extPort = extPort,
extMultiAddrs = extMultiAddrs,
wsBindPort = Port(uint16(conf.websocketPort) + conf.portsShift),
wsEnabled = conf.websocketSupport,
wssEnabled = conf.websocketSecureSupport,
dns4DomainName = dns4DomainName,
discv5UdpPort = discv5UdpPort,
wakuFlags = some(wakuFlags),
))
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
discoveryConfig = DiscoveryConfig.init(
conf.discv5TableIpLimit, conf.discv5BucketIpLimit, conf.discv5BitsPerHop)
# 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)
let dynamicBootstrapEnrs = dynamicBootstrapNodes
.filterIt(it.hasUdpPort())
.mapIt(it.enr.get())
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)
node.wakuDiscv5 = WakuDiscoveryV5.new(
extIP, extPort, discv5UdpPort,
conf.listenAddress,
discv5UdpPort.get(),
discv5BootstrapEnrs,
conf.discv5EnrAutoUpdate,
keys.PrivateKey(nodekey.skkey),
wakuFlags,
[], # Empty enr fields, for now
node.rng,
discoveryConfig
)
discv5BootstrapEnrs.add(dynamicBootstrapEnrs)
let discv5Config = DiscoveryConfig.init(conf.discv5TableIpLimit,
conf.discv5BucketIpLimit,
conf.discv5BitsPerHop)
try:
wakuDiscv5 = some(WakuDiscoveryV5.new(
extIp = netConfig.extIp,
extTcpPort = netConfig.extPort,
extUdpPort = netConfig.discv5UdpPort,
bindIp = netConfig.bindIp,
discv5UdpPort = netConfig.discv5UdpPort.get(),
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)

1
examples/v2/publisher.nim
View File

@ -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()

1
examples/v2/subscriber.nim
View File

@ -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()

10
tests/v2/test_enr_utils.nim
View File

@ -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),

80
tests/v2/test_waku_discv5.nim
View File

@ -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)

4
tests/v2/test_waku_peer_exchange.nim
View File

@ -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
)

12
waku/v2/node/discv5/waku_discv5.nim
View File

@ -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
)

179
waku/v2/node/waku_node.nim
View File

@ -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,
nodeKey: crypto.PrivateKey,
type NetConfig* = object
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
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.
wakuFlags = none(WakuEnrBitfield)
): T {.raises: [LPError]} =
## 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,
wsHostAddress,
address = netConfig.hostAddress,
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,
announcedAddresses: announcedAddresses
enr: netConfig.getEnr(wakuDiscv5, nodekey),
announcedAddresses: netConfig.announcedAddresses,
wakuDiscv5: if wakuDiscV5.isSome(): wakuDiscV5.get() else: nil,
)
return wakuNode
proc peerInfo*(node: WakuNode): PeerInfo =
node.switch.peerInfo

15
waku/v2/utils/peers.nim
View File

@ -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()

23
waku/v2/utils/wakuenr.nim
View File

@ -34,10 +34,7 @@ type
Filter = 2,
Lightpush = 3,
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/
func getRawField*(multiaddrs: seq[MultiAddress]): seq[byte] =
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.initEnr(..., capabilities=[Store, Lightpush, Relay, Filter])
# WaKuEnr.enr.Record.init(..., capabilities=[Store, Lightpush])
# 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