logos-messaging/logos-messaging-nim
1
0
Fork 0
mirror of https://github.com/logos-messaging/logos-messaging-nim.git synced 2026-01-04 23:13:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: vendor bump for 0.23.0 (#2274)

Browse Source 
* on_chain/group_manager: use .async: (raises:[Exception]).
* bump nim-dnsdisc
* update nim-chronos to the latest state
* chat2.nim: catch any possible exception when stopping
* chat2bridge.nim: make it to compile after vendor bump
* ValidIpAddress (deprecated) -> IpAddress
* vendor/nim-libp2p additional bump
* libwaku: adapt to vendor bump
* testlib/wakunode.nim: adapt to vendor bump (ValidIpAddress -> IpAddress)
* waku_node: avoid throwing any exception from stop*(node: WakuNode)
* test_confutils_envvar.nim: ValidIpAddress -> IpAddress
* test_jsonrpc_store: capture exception
* test_rln*: handling exceptions
* adaptation to make test_rln_* to work properly
* signature enhancement of group_manager methods
This commit is contained in:
Ivan FB 2023-12-14 07:16:39 +01:00 committed by GitHub
parent ac3a3737de
commit 7c692cc313
81 changed files with 626 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
apps/chat2/chat2.nim
View File

@ -154,7 +154,7 @@ proc readNick(transp: StreamTransport): Future[string] {.async.} =
return await transp.readLine()
proc startMetricsServer(serverIp: ValidIpAddress, serverPort: Port): Result[MetricsHttpServerRef, string] =
proc startMetricsServer(serverIp: IpAddress, serverPort: Port): Result[MetricsHttpServerRef, string] =
info "Starting metrics HTTP server", serverIp= $serverIp, serverPort= $serverPort
let metricsServerRes = MetricsHttpServerRef.new($serverIp, serverPort)
@ -269,7 +269,10 @@ proc writeAndPrint(c: Chat) {.async.} =
echo "quitting..."
await c.node.stop()
try:
await c.node.stop()
except:
echo "exception happened when stopping: " & getCurrentExceptionMsg()
quit(QuitSuccess)
else:

24
apps/chat2/config_chat2.nim
View File

@ -30,7 +30,7 @@ type
listenAddress* {.
defaultValue: defaultListenAddress(config)
desc: "Listening address for the LibP2P traffic."
name: "listen-address"}: ValidIpAddress
name: "listen-address"}: IpAddress
tcpPort* {.
desc: "TCP listening port."
@ -135,8 +135,8 @@ type
rpcAddress* {.
desc: "Listening address of the JSON-RPC server.",
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "rpc-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "rpc-address" }: IpAddress
rpcPort* {.
desc: "Listening port of the JSON-RPC server.",
@ -162,8 +162,8 @@ type
metricsServerAddress* {.
desc: "Listening address of the metrics server."
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "metrics-server-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "metrics-server-address" }: IpAddress
metricsServerPort* {.
desc: "Listening HTTP port of the metrics server."
@ -189,8 +189,8 @@ type
dnsDiscoveryNameServers* {.
desc: "DNS name server IPs to query. Argument may be repeated."
defaultValue: @[ValidIpAddress.init("1.1.1.1"), ValidIpAddress.init("1.0.0.1")]
name: "dns-discovery-name-server" }: seq[ValidIpAddress]
defaultValue: @[parseIpAddress("1.1.1.1"), parseIpAddress("1.0.0.1")]
name: "dns-discovery-name-server" }: seq[IpAddress]
## Chat2 configuration
@ -278,13 +278,13 @@ proc parseCmdArg*(T: type crypto.PrivateKey, p: string): T =
proc completeCmdArg*(T: type crypto.PrivateKey, val: string): seq[string] =
return @[]
proc parseCmdArg*(T: type ValidIpAddress, p: string): T =
proc parseCmdArg*(T: type IpAddress, p: string): T =
try:
result = ValidIpAddress.init(p)
result = parseIpAddress(p)
except CatchableError as e:
raise newException(ValueError, "Invalid IP address")
proc completeCmdArg*(T: type ValidIpAddress, val: string): seq[string] =
proc completeCmdArg*(T: type IpAddress, val: string): seq[string] =
return @[]
proc parseCmdArg*(T: type Port, p: string): T =
@ -302,7 +302,7 @@ proc parseCmdArg*(T: type Option[uint], p: string): T =
except CatchableError:
raise newException(ValueError, "Invalid unsigned integer")
func defaultListenAddress*(conf: Chat2Conf): ValidIpAddress =
func defaultListenAddress*(conf: Chat2Conf): IpAddress =
# TODO: How should we select between IPv4 and IPv6
# Maybe there should be a config option for this.
(static ValidIpAddress.init("0.0.0.0"))
(static parseIpAddress("0.0.0.0"))

22
apps/chat2bridge/chat2bridge.nim
View File

@ -8,7 +8,8 @@ import
chronos, confutils, chronicles, chronicles/topics_registry, chronos/streams/tlsstream,
metrics, metrics/chronos_httpserver,
stew/byteutils,
stew/shims/net as stewNet, json_rpc/rpcserver,
eth/net/nat,
json_rpc/rpcserver,
# Matterbridge client imports
../../waku/common/utils/matterbridge_client,
# Waku v2 imports
@ -51,7 +52,7 @@ type
seen: seq[Hash] #FIFO queue
contentTopic: string
MbMessageHandler* = proc (jsonNode: JsonNode) {.gcsafe.}
MbMessageHandler = proc (jsonNode: JsonNode) {.async.}
###################
# Helper funtions #
@ -129,7 +130,7 @@ proc pollMatterbridge(cmb: Chat2MatterBridge, handler: MbMessageHandler) {.async
if getRes.isOk():
for jsonNode in getRes[]:
handler(jsonNode)
await handler(jsonNode)
else:
error "Matterbridge host unreachable. Sleeping before retrying."
await sleepAsync(chronos.seconds(10))
@ -145,8 +146,8 @@ proc new*(T: type Chat2MatterBridge,
mbGateway: string,
# NodeV2 initialisation
nodev2Key: crypto.PrivateKey,
nodev2BindIp: ValidIpAddress, nodev2BindPort: Port,
nodev2ExtIp = none[ValidIpAddress](), nodev2ExtPort = none[Port](),
nodev2BindIp: IpAddress, nodev2BindPort: Port,
nodev2ExtIp = none[IpAddress](), nodev2ExtPort = none[Port](),
contentTopic: string): T
{.raises: [Defect, ValueError, KeyError, TLSStreamProtocolError, IOError, LPError].} =
@ -183,7 +184,7 @@ proc start*(cmb: Chat2MatterBridge) {.async.} =
debug "Start polling Matterbridge"
# Start Matterbridge polling (@TODO: use streaming interface)
proc mbHandler(jsonNode: JsonNode) {.gcsafe, raises: [Exception].} =
proc mbHandler(jsonNode: JsonNode) {.async.} =
trace "Bridging message from Matterbridge to chat2", jsonNode=jsonNode
waitFor cmb.toChat2(jsonNode)
@ -200,13 +201,16 @@ proc start*(cmb: Chat2MatterBridge) {.async.} =
# Bridging
# Handle messages on Waku v2 and bridge to Matterbridge
proc relayHandler(pubsubTopic: PubsubTopic, msg: WakuMessage): Future[void] {.async, gcsafe.} =
proc relayHandler(pubsubTopic: PubsubTopic, msg: WakuMessage): Future[void] {.async.} =
trace "Bridging message from Chat2 to Matterbridge", msg=msg
cmb.toMatterbridge(msg)
try:
cmb.toMatterbridge(msg)
except:
error "exception in relayHandler: " & getCurrentExceptionMsg()
cmb.nodev2.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), some(relayHandler))
proc stop*(cmb: Chat2MatterBridge) {.async.} =
proc stop*(cmb: Chat2MatterBridge) {.async: (raises: [Exception]).} =
info "Stopping Chat2MatterBridge"
cmb.running = false

24
apps/chat2bridge/config_chat2bridge.nim
View File

@ -13,7 +13,7 @@ type
listenAddress* {.
defaultValue: defaultListenAddress(config)
desc: "Listening address for the LibP2P traffic"
name: "listen-address"}: ValidIpAddress
name: "listen-address"}: IpAddress
libp2pTcpPort* {.
desc: "Libp2p TCP listening port (for Waku v2)"
@ -42,8 +42,8 @@ type
rpcAddress* {.
desc: "Listening address of the RPC server",
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "rpc-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "rpc-address" }: IpAddress
rpcPort* {.
desc: "Listening port of the RPC server"
@ -57,8 +57,8 @@ type
metricsServerAddress* {.
desc: "Listening address of the metrics server"
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "metrics-server-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "metrics-server-address" }: IpAddress
metricsServerPort* {.
desc: "Listening HTTP port of the metrics server"
@ -109,8 +109,8 @@ type
# Matterbridge options
mbHostAddress* {.
desc: "Listening address of the Matterbridge host",
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "mb-host-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "mb-host-address" }: IpAddress
mbHostPort* {.
desc: "Listening port of the Matterbridge host",
@ -149,14 +149,14 @@ proc parseCmdArg*(T: type crypto.PrivateKey, p: string): T =
proc completeCmdArg*(T: type crypto.PrivateKey, val: string): seq[string] =
return @[]
proc parseCmdArg*(T: type ValidIpAddress, p: string): T =
proc parseCmdArg*(T: type IpAddress, p: string): T =
try:
result = ValidIpAddress.init(p)
result = parseIpAddress(p)
except CatchableError:
raise newException(ValueError, "Invalid IP address")
proc completeCmdArg*(T: type ValidIpAddress, val: string): seq[string] =
proc completeCmdArg*(T: type IpAddress, val: string): seq[string] =
return @[]
func defaultListenAddress*(conf: Chat2MatterbridgeConf): ValidIpAddress =
(static ValidIpAddress.init("0.0.0.0"))
func defaultListenAddress*(conf: Chat2MatterbridgeConf): IpAddress =
(parseIpAddress("0.0.0.0"))

8
apps/networkmonitor/networkmonitor.nim
View File

@ -300,7 +300,7 @@ proc crawlNetwork(node: WakuNode,
await sleepAsync(crawlInterval.millis - elapsed.millis)
proc retrieveDynamicBootstrapNodes(dnsDiscovery: bool, dnsDiscoveryUrl: string, dnsDiscoveryNameServers: seq[ValidIpAddress]): Result[seq[RemotePeerInfo], string] =
proc retrieveDynamicBootstrapNodes(dnsDiscovery: bool, dnsDiscoveryUrl: string, dnsDiscoveryNameServers: seq[IpAddress]): Result[seq[RemotePeerInfo], string] =
if dnsDiscovery and dnsDiscoveryUrl != "":
# DNS discovery
debug "Discovering nodes using Waku DNS discovery", url=dnsDiscoveryUrl
@ -328,7 +328,7 @@ proc retrieveDynamicBootstrapNodes(dnsDiscovery: bool, dnsDiscoveryUrl: string,
proc getBootstrapFromDiscDns(conf: NetworkMonitorConf): Result[seq[enr.Record], string] =
try:
let dnsNameServers = @[ValidIpAddress.init("1.1.1.1"), ValidIpAddress.init("1.0.0.1")]
let dnsNameServers = @[parseIpAddress("1.1.1.1"), parseIpAddress("1.0.0.1")]
let dynamicBootstrapNodesRes = retrieveDynamicBootstrapNodes(true, conf.dnsDiscoveryUrl, dnsNameServers)
if not dynamicBootstrapNodesRes.isOk():
error("failed discovering peers from DNS")
@ -350,12 +350,12 @@ proc getBootstrapFromDiscDns(conf: NetworkMonitorConf): Result[seq[enr.Record],
proc initAndStartApp(conf: NetworkMonitorConf): Result[(WakuNode, WakuDiscoveryV5), string] =
let bindIp = try:
ValidIpAddress.init("0.0.0.0")
parseIpAddress("0.0.0.0")
except CatchableError:
return err("could not start node: " & getCurrentExceptionMsg())
let extIp = try:
ValidIpAddress.init("127.0.0.1")
parseIpAddress("127.0.0.1")
except CatchableError:
return err("could not start node: " & getCurrentExceptionMsg())

10
apps/networkmonitor/networkmonitor_config.nim
View File

@ -46,8 +46,8 @@ type
metricsServerAddress* {.
desc: "Listening address of the metrics server."
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "metrics-server-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "metrics-server-address" }: IpAddress
metricsServerPort* {.
desc: "Listening HTTP port of the metrics server."
@ -64,13 +64,13 @@ type
defaultValue: 8009,
name: "metrics-rest-port" }: uint16
proc parseCmdArg*(T: type ValidIpAddress, p: string): T =
proc parseCmdArg*(T: type IpAddress, p: string): T =
try:
result = ValidIpAddress.init(p)
result = parseIpAddress(p)
except CatchableError as e:
raise newException(ValueError, "Invalid IP address")
proc completeCmdArg*(T: type ValidIpAddress, val: string): seq[string] =
proc completeCmdArg*(T: type IpAddress, val: string): seq[string] =
return @[]
proc parseCmdArg*(T: type chronos.Duration, p: string): T =

2
apps/networkmonitor/networkmonitor_metrics.nim
View File

@ -90,7 +90,7 @@ proc installHandler*(router: var RestRouter,
# TODO: toJson() includes the hash
return RestApiResponse.response($(%numMessagesPerContentTopic), contentType="application/json")
proc startMetricsServer*(serverIp: ValidIpAddress, serverPort: Port): Result[void, string] =
proc startMetricsServer*(serverIp: IpAddress, serverPort: Port): Result[void, string] =
info "Starting metrics HTTP server", serverIp, serverPort
try:

6
apps/wakucanary/wakucanary.nim
View File

@ -121,8 +121,8 @@ proc main(rng: ref HmacDrbgContext): Future[int] {.async.} =
# create dns resolver
let
nameServers = @[
initTAddress(ValidIpAddress.init("1.1.1.1"), Port(53)),
initTAddress(ValidIpAddress.init("1.0.0.1"), Port(53))]
initTAddress(parseIpAddress("1.1.1.1"), Port(53)),
initTAddress(parseIpAddress("1.0.0.1"), Port(53))]
resolver: DnsResolver = DnsResolver.new(nameServers)
if conf.logLevel != LogLevel.NONE:
@ -149,7 +149,7 @@ proc main(rng: ref HmacDrbgContext): Future[int] {.async.} =
let
nodeKey = crypto.PrivateKey.random(Secp256k1, rng[])[]
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
wsBindPort = Port(conf.nodePort + WebSocketPortOffset)
nodeTcpPort = Port(conf.nodePort)
isWs = peer.addrs[0].contains(multiCodec("ws")).get()

13
apps/wakunode2/app.nim
View File

@ -181,7 +181,10 @@ proc setupPeerPersistence*(app: var App): AppResult[void] =
## Retrieve dynamic bootstrap nodes (DNS discovery)
proc retrieveDynamicBootstrapNodes*(dnsDiscovery: bool, dnsDiscoveryUrl: string, dnsDiscoveryNameServers: seq[ValidIpAddress]): AppResult[seq[RemotePeerInfo]] =
proc retrieveDynamicBootstrapNodes*(dnsDiscovery: bool,
dnsDiscoveryUrl: string,
dnsDiscoveryNameServers: seq[IpAddress]):
AppResult[seq[RemotePeerInfo]] =
if dnsDiscovery and dnsDiscoveryUrl != "":
# DNS discovery
@ -647,7 +650,7 @@ proc startApp*(app: var App): AppResult[void] =
## Monitoring and external interfaces
proc startRestServer(app: App, address: ValidIpAddress, port: Port, conf: WakuNodeConf): AppResult[RestServerRef] =
proc startRestServer(app: App, address: IpAddress, port: Port, conf: WakuNodeConf): AppResult[RestServerRef] =
# Used to register api endpoints that are not currently installed as keys,
# values are holding error messages to be returned to the client
@ -752,7 +755,7 @@ proc startRestServer(app: App, address: ValidIpAddress, port: Port, conf: WakuNo
ok(server)
proc startRpcServer(app: App, address: ValidIpAddress, port: Port, conf: WakuNodeConf): AppResult[RpcHttpServer] =
proc startRpcServer(app: App, address: IpAddress, port: Port, conf: WakuNodeConf): AppResult[RpcHttpServer] =
let ta = initTAddress(address, port)
var server: RpcHttpServer
@ -792,7 +795,7 @@ proc startRpcServer(app: App, address: ValidIpAddress, port: Port, conf: WakuNod
ok(server)
proc startMetricsServer(serverIp: ValidIpAddress, serverPort: Port): AppResult[MetricsHttpServerRef] =
proc startMetricsServer(serverIp: IpAddress, serverPort: Port): AppResult[MetricsHttpServerRef] =
info "Starting metrics HTTP server", serverIp= $serverIp, serverPort= $serverPort
let metricsServerRes = MetricsHttpServerRef.new($serverIp, serverPort)
@ -845,7 +848,7 @@ proc setupMonitoringAndExternalInterfaces*(app: var App): AppResult[void] =
# App shutdown
proc stop*(app: App): Future[void] {.async.} =
proc stop*(app: App): Future[void] {.async: (raises: [Exception]).} =
if app.restServer.isSome():
await app.restServer.get().stop()

32
apps/wakunode2/external_config.nim
View File

@ -112,7 +112,7 @@ type
listenAddress* {.
defaultValue: defaultListenAddress()
desc: "Listening address for LibP2P (and Discovery v5, if enabled) traffic."
name: "listen-address"}: ValidIpAddress
name: "listen-address"}: IpAddress
tcpPort* {.
desc: "TCP listening port."
@ -165,8 +165,8 @@ type
dnsAddrsNameServers* {.
desc: "DNS name server IPs to query for DNS multiaddrs resolution. Argument may be repeated."
defaultValue: @[ValidIpAddress.init("1.1.1.1"), ValidIpAddress.init("1.0.0.1")]
name: "dns-addrs-name-server" }: seq[ValidIpAddress]
defaultValue: @[parseIpAddress("1.1.1.1"), parseIpAddress("1.0.0.1")]
name: "dns-addrs-name-server" }: seq[IpAddress]
dns4DomainName* {.
desc: "The domain name resolving to the node's public IPv4 address",
@ -316,8 +316,8 @@ type
rpcAddress* {.
desc: "Listening address of the JSON-RPC server.",
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "rpc-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "rpc-address" }: IpAddress
rpcPort* {.
desc: "Listening port of the JSON-RPC server.",
@ -343,8 +343,8 @@ type
restAddress* {.
desc: "Listening address of the REST HTTP server.",
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "rest-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "rest-address" }: IpAddress
restPort* {.
desc: "Listening port of the REST HTTP server.",
@ -375,8 +375,8 @@ type
metricsServerAddress* {.
desc: "Listening address of the metrics server."
defaultValue: ValidIpAddress.init("127.0.0.1")
name: "metrics-server-address" }: ValidIpAddress
defaultValue: parseIpAddress("127.0.0.1")
name: "metrics-server-address" }: IpAddress
metricsServerPort* {.
desc: "Listening HTTP port of the metrics server."
@ -402,8 +402,8 @@ type
dnsDiscoveryNameServers* {.
desc: "DNS name server IPs to query. Argument may be repeated."
defaultValue: @[ValidIpAddress.init("1.1.1.1"), ValidIpAddress.init("1.0.0.1")]
name: "dns-discovery-name-server" }: seq[ValidIpAddress]
defaultValue: @[parseIpAddress("1.1.1.1"), parseIpAddress("1.0.0.1")]
name: "dns-discovery-name-server" }: seq[IpAddress]
## Discovery v5 config
@ -510,19 +510,19 @@ proc parseCmdArg*(T: type ProtectedTopic, p: string): T =
proc completeCmdArg*(T: type ProtectedTopic, val: string): seq[string] =
return @[]
proc parseCmdArg*(T: type ValidIpAddress, p: string): T =
proc parseCmdArg*(T: type IpAddress, p: string): T =
try:
ValidIpAddress.init(p)
parseIpAddress(p)
except CatchableError:
raise newException(ValueError, "Invalid IP address")
proc completeCmdArg*(T: type ValidIpAddress, val: string): seq[string] =
proc completeCmdArg*(T: type IpAddress, val: string): seq[string] =
return @[]
proc defaultListenAddress*(): ValidIpAddress =
proc defaultListenAddress*(): IpAddress =
# TODO: How should we select between IPv4 and IPv6
# Maybe there should be a config option for this.
(static ValidIpAddress.init("0.0.0.0"))
(static parseIpAddress("0.0.0.0"))
proc parseCmdArg*(T: type Port, p: string): T =
try:

4
apps/wakunode2/internal_config.nim
View File

@ -143,13 +143,13 @@ proc networkConfiguration*(conf: WakuNodeConf,
if dnsRes.isErr():
return err($dnsRes.error) # Pass error down the stack
extIp = some(ValidIpAddress.init(dnsRes.get()))
extIp = some(parseIpAddress(dnsRes.get()))
except CatchableError:
return err("Could not update extIp to resolved DNS IP: " & getCurrentExceptionMsg())
# 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
# than IpAddress, which doesn't allow default construction
let netConfigRes = NetConfig.init(
clusterId = conf.clusterId,
bindIp = conf.listenAddress,

2
apps/wakunode2/wakunode2.nim
View File

@ -107,7 +107,7 @@ when isMainModule:
## Setup shutdown hooks for this process.
## Stop node gracefully on shutdown.
proc asyncStopper(node: App) {.async.} =
proc asyncStopper(node: App) {.async: (raises: [Exception]).} =
await node.stop()
quit(QuitSuccess)

2
examples/publisher.nim
View File

@ -40,7 +40,7 @@ proc setupAndPublish(rng: ref HmacDrbgContext) {.async.} =
notice "starting publisher", wakuPort=wakuPort, discv5Port=discv5Port
let
nodeKey = crypto.PrivateKey.random(Secp256k1, rng[]).get()
ip = ValidIpAddress.init("0.0.0.0")
ip = parseIpAddress("0.0.0.0")
flags = CapabilitiesBitfield.init(lightpush = false, filter = false, store = false, relay = true)
var builder = WakuNodeBuilder.init()

2
examples/subscriber.nim
View File

@ -35,7 +35,7 @@ proc setupAndSubscribe(rng: ref HmacDrbgContext) {.async.} =
notice "starting subscriber", wakuPort=wakuPort, discv5Port=discv5Port
let
nodeKey = crypto.PrivateKey.random(Secp256k1, rng[])[]
ip = ValidIpAddress.init("0.0.0.0")
ip = parseIpAddress("0.0.0.0")
flags = CapabilitiesBitfield.init(lightpush = false, filter = false, store = false, relay = true)
var builder = WakuNodeBuilder.init()

2
library/callback.nim
View File

@ -2,4 +2,4 @@
type
WakuCallBack* = proc(callerRet: cint,
msg: ptr cchar,
len: csize_t) {.cdecl, gcsafe.}
len: csize_t) {.cdecl, gcsafe, raises: [].}

2
library/events/json_error_event.nim
View File

@ -14,5 +14,5 @@ proc new*(T: type JsonErrorEvent,
eventType: "error",
message: message)
method `$`*(jsonError: JsonErrorEvent): string =
method `$`*(jsonError: JsonErrorEvent): string {.raises: [].}=
$( %* jsonError )

2
library/libwaku.nim
View File

@ -44,7 +44,7 @@ const RET_MISSING_CALLBACK: cint = 2
var extEventCallback*: WakuCallBack = nil
proc relayEventCallback(pubsubTopic: PubsubTopic,
msg: WakuMessage): Future[void] {.async, gcsafe.} =
msg: WakuMessage): Future[void] {.async.} =
# Callback that hadles the Waku Relay events. i.e. messages or errors.
if not isNil(extEventCallback):
try:

51
library/waku_thread/config.nim
View File

@ -37,7 +37,7 @@ proc parsePrivateKey(jsonNode: JsonNode,
return true
proc parseListenAddr(jsonNode: JsonNode,
listenAddr: var ValidIpAddress,
listenAddr: var IpAddress,
jsonResp: var JsonEvent): bool =
if not jsonNode.contains("host"):
@ -51,7 +51,7 @@ proc parseListenAddr(jsonNode: JsonNode,
let host = jsonNode["host"].getStr()
try:
listenAddr = ValidIpAddress.init(host)
listenAddr = parseIpAddress(host)
except CatchableError:
let msg = "Invalid host IP address: " & getCurrentExceptionMsg()
jsonResp = JsonErrorEvent.new(msg)
@ -175,7 +175,7 @@ proc parseConfig*(configNodeJson: string,
storeVacuum: var bool,
storeDbMigration: var bool,
storeMaxNumDbConnections: var int,
jsonResp: var JsonEvent): bool =
jsonResp: var JsonEvent): bool {.raises: [].} =
if configNodeJson.len == 0:
jsonResp = JsonErrorEvent.new("The configNodeJson is empty")
@ -184,29 +184,42 @@ proc parseConfig*(configNodeJson: string,
var jsonNode: JsonNode
try:
jsonNode = parseJson(configNodeJson)
except JsonParsingError:
except Exception, IOError, JsonParsingError:
jsonResp = JsonErrorEvent.new("Exception: " & getCurrentExceptionMsg())
return false
# key
if not parsePrivateKey(jsonNode, privateKey, jsonResp):
try:
if not parsePrivateKey(jsonNode, privateKey, jsonResp):
return false
except Exception, KeyError:
jsonResp = JsonErrorEvent.new("Exception calling parsePrivateKey: " & getCurrentExceptionMsg())
return false
# listenAddr
var listenAddr = ValidIpAddress.init("127.0.0.1")
if not parseListenAddr(jsonNode, listenAddr, jsonResp):
var listenAddr: IpAddress
try:
listenAddr = parseIpAddress("127.0.0.1")
if not parseListenAddr(jsonNode, listenAddr, jsonResp):
return false
except Exception, ValueError:
jsonResp = JsonErrorEvent.new("Exception calling parseIpAddress: " & getCurrentExceptionMsg())
return false
# port
var port = 0
if not parsePort(jsonNode, port, jsonResp):
try:
if not parsePort(jsonNode, port, jsonResp):
return false
except Exception, ValueError:
jsonResp = JsonErrorEvent.new("Exception calling parsePort: " & getCurrentExceptionMsg())
return false
let natRes = setupNat("any", clientId,
Port(uint16(port)),
Port(uint16(port)))
if natRes.isErr():
jsonResp = JsonErrorEvent.new(fmt"failed to setup NAT: {$natRes.error}")
jsonResp = JsonErrorEvent.new("failed to setup NAT: " & $natRes.error)
return false
let (extIp, extTcpPort, _) = natRes.get()
@ -217,15 +230,27 @@ proc parseConfig*(configNodeJson: string,
extTcpPort
# relay
if not parseRelay(jsonNode, relay, jsonResp):
try:
if not parseRelay(jsonNode, relay, jsonResp):
return false
except Exception, KeyError:
jsonResp = JsonErrorEvent.new("Exception calling parseRelay: " & getCurrentExceptionMsg())
return false
# topics
parseTopics(jsonNode, topics)
try:
parseTopics(jsonNode, topics)
except Exception, KeyError:
jsonResp = JsonErrorEvent.new("Exception calling parseTopics: " & getCurrentExceptionMsg())
return false
# store
if not parseStore(jsonNode, store, storeNode, storeRetentionPolicy, storeDbUrl,
storeVacuum, storeDbMigration, storeMaxNumDbConnections, jsonResp):
try:
if not parseStore(jsonNode, store, storeNode, storeRetentionPolicy, storeDbUrl,
storeVacuum, storeDbMigration, storeMaxNumDbConnections, jsonResp):
return false
except Exception, KeyError:
jsonResp = JsonErrorEvent.new("Exception calling parseStore: " & getCurrentExceptionMsg())
return false
let wakuFlags = CapabilitiesBitfield.init(

39
library/waku_thread/inter_thread_communication/requests/node_lifecycle_request.nim
View File

@ -107,9 +107,8 @@ proc createNode(configJson: cstring):
Future[Result[WakuNode, string]] {.async.} =
var privateKey: PrivateKey
var netConfig = NetConfig.init(ValidIpAddress.init("127.0.0.1"),
var netConfig = NetConfig.init(parseIpAddress("127.0.0.1"),
Port(60000'u16)).value
## relay
var relay: bool
var topics = @[""]
@ -125,20 +124,23 @@ proc createNode(configJson: cstring):
var jsonResp: JsonEvent
if not parseConfig($configJson,
privateKey,
netConfig,
relay,
topics,
store,
storeNode,
storeRetentionPolicy,
storeDbUrl,
storeVacuum,
storeDbMigration,
storeMaxNumDbConnections,
jsonResp):
return err($jsonResp)
try:
if not parseConfig($configJson,
privateKey,
netConfig,
relay,
topics,
store,
storeNode,
storeRetentionPolicy,
storeDbUrl,
storeVacuum,
storeDbMigration,
storeMaxNumDbConnections,
jsonResp):
return err($jsonResp)
except Exception:
return err("exception calling parseConfig: " & getCurrentExceptionMsg())
var enrBuilder = EnrBuilder.init(privateKey)
@ -217,6 +219,9 @@ proc process*(self: ptr NodeLifecycleRequest,
await node[].start()
of STOP_NODE:
await node[].stop()
try:
await node[].stop()
except Exception:
return err("exception stopping node: " & getCurrentExceptionMsg())
return ok("")

6
tests/common/test_confutils_envvar.nim
View File

@ -24,9 +24,9 @@ type TestConf = object
name: "test-file" }: Option[InputFile]
listenAddress* {.
defaultValue: ValidIpAddress.init("127.0.0.1"),
defaultValue: parseIpAddress("127.0.0.1"),
desc: "Listening address",
name: "listen-address"}: ValidIpAddress
name: "listen-address"}: IpAddress
tcpPort* {.
desc: "TCP listening port",
@ -70,7 +70,7 @@ suite "nim-confutils - envvar":
let conf = confLoadRes.get()
check:
conf.listenAddress == ValidIpAddress.init(listenAddress)
conf.listenAddress == parseIpAddress(listenAddress)
conf.tcpPort == Port(8080)
conf.configFile.isSome()

6
tests/common/test_enr_builder.nim
View File

@ -61,7 +61,7 @@ suite "nim-eth ENR - Ext: IP address and TCP/UDP ports":
seqNum = 1u64
privateKey = ethSecp256k1Key("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
enrIpAddr = ValidIpAddress.init("127.0.0.1")
enrIpAddr = parseIpAddress("127.0.0.1")
enrUdpPort = Port(30303)
## When
@ -82,7 +82,7 @@ suite "nim-eth ENR - Ext: IP address and TCP/UDP ports":
seqNum = 1u64
privateKey = generateSecp256k1Key()
enrIpAddr = ValidIpAddress.init("127.0.0.1")
enrIpAddr = parseIpAddress("127.0.0.1")
enrTcpPort = Port(30301)
let expectedPubKey = privateKey.getPublicKey().get().getRawBytes().get()
@ -112,7 +112,7 @@ suite "nim-eth ENR - Ext: IP address and TCP/UDP ports":
seqNum = 1u64
privateKey = generateSecp256k1Key()
enrIpAddr = ValidIpAddress.init("::1")
enrIpAddr = parseIpAddress("::1")
enrUdpPort = Port(30301)
let expectedPubKey = privateKey.getPublicKey().get().getRawBytes().get()

6
tests/node/test_wakunode_filter.nim
View File

@ -60,8 +60,8 @@ suite "Waku Filter - End to End":
serverKey = generateSecp256k1Key()
clientKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(server.start(), client.start())
@ -140,7 +140,7 @@ suite "Waku Filter - End to End":
# Given a server node with Relay without Filter
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor server.start()
waitFor server.mountRelay()

2
tests/test_peer_exchange.nim
View File

@ -21,7 +21,7 @@ procSuite "Peer Exchange":
# Create nodes and ENR. These will be added to the discoverable list
let
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, bindIp, Port(0))
nodeKey2 = generateSecp256k1Key()

42
tests/test_peer_manager.nim
View File

@ -37,7 +37,7 @@ import
procSuite "Peer Manager":
asyncTest "connectRelay() works":
# Create 2 nodes
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
let connOk = await nodes[0].peerManager.connectRelay(nodes[1].peerInfo.toRemotePeerInfo())
@ -50,7 +50,7 @@ procSuite "Peer Manager":
asyncTest "dialPeer() works":
# Create 2 nodes
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -78,7 +78,7 @@ procSuite "Peer Manager":
asyncTest "dialPeer() fails gracefully":
# Create 2 nodes and start them
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -101,7 +101,7 @@ procSuite "Peer Manager":
asyncTest "Adding, selecting and filtering peers work":
let
node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
# Create filter peer
filterLoc = MultiAddress.init("/ip4/127.0.0.1/tcp/0").tryGet()
@ -132,7 +132,7 @@ procSuite "Peer Manager":
asyncTest "Peer manager keeps track of connections":
# Create 2 nodes
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -176,7 +176,7 @@ procSuite "Peer Manager":
asyncTest "Peer manager updates failed peers correctly":
# Create 2 nodes
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -228,11 +228,11 @@ procSuite "Peer Manager":
storage = WakuPeerStorage.new(database)[]
node1 = newTestWakuNode(
generateSecp256k1Key(),
ValidIpAddress.init("127.0.0.1"),
parseIpAddress("127.0.0.1"),
Port(44048),
peerStorage = storage
)
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(34023))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(34023))
node1.mountMetadata(0).expect("Mounted Waku Metadata")
node2.mountMetadata(0).expect("Mounted Waku Metadata")
@ -265,7 +265,7 @@ procSuite "Peer Manager":
# Simulate restart by initialising a new node using the same storage
let node3 = newTestWakuNode(
generateSecp256k1Key(),
ValidIpAddress.init("127.0.0.1"),
parseIpAddress("127.0.0.1"),
Port(56037),
peerStorage = storage
)
@ -302,7 +302,7 @@ procSuite "Peer Manager":
# different network
node1 = newTestWakuNode(
generateSecp256k1Key(),
ValidIpAddress.init("0.0.0.0"),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId3,
topics = @["/waku/2/rs/3/0"],
@ -311,14 +311,14 @@ procSuite "Peer Manager":
# same network
node2 = newTestWakuNode(
generateSecp256k1Key(),
ValidIpAddress.init("0.0.0.0"),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId4,
topics = @["/waku/2/rs/4/0"],
)
node3 = newTestWakuNode(
generateSecp256k1Key(),
ValidIpAddress.init("0.0.0.0"),
parseIpAddress("0.0.0.0"),
Port(0),
clusterId = clusterId4,
topics = @["/waku/2/rs/4/0"],
@ -350,8 +350,8 @@ procSuite "Peer Manager":
let
database = SqliteDatabase.new(":memory:")[]
storage = WakuPeerStorage.new(database)[]
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0), peerStorage = storage)
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), peerStorage = storage)
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
peerInfo2 = node2.switch.peerInfo
betaCodec = "/vac/waku/relay/2.0.0-beta2"
stableCodec = "/vac/waku/relay/2.0.0"
@ -375,7 +375,7 @@ procSuite "Peer Manager":
# Simulate restart by initialising a new node using the same storage
let
node3 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0), peerStorage = storage)
node3 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), peerStorage = storage)
await node3.mountRelay()
node3.wakuRelay.codec = stableCodec
@ -408,7 +408,7 @@ procSuite "Peer Manager":
.mapIt(
newTestWakuNode(
nodeKey = generateSecp256k1Key(),
bindIp = ValidIpAddress.init("0.0.0.0"),
bindIp = parseIpAddress("0.0.0.0"),
bindPort = Port(0),
wakuFlags = some(CapabilitiesBitfield.init(@[Relay]))
)
@ -457,7 +457,7 @@ procSuite "Peer Manager":
asyncTest "Peer store keeps track of incoming connections":
# Create 4 nodes
let nodes = toSeq(0..<4).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<4).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Start them
await allFutures(nodes.mapIt(it.start()))
@ -520,7 +520,7 @@ procSuite "Peer Manager":
let basePeerId = "16Uiu2HAm7QGEZKujdSbbo1aaQyfDPQ6Bw3ybQnj6fruH5Dxwd7D"
let
node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
peers = toSeq(1..5)
.mapIt(
parsePeerInfo("/ip4/0.0.0.0/tcp/30300/p2p/" & basePeerId & $it)
@ -562,7 +562,7 @@ procSuite "Peer Manager":
asyncTest "connectedPeers() returns expected number of connections per protocol":
# Create 4 nodes
let nodes = toSeq(0..<4).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<4).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))
@ -613,7 +613,7 @@ procSuite "Peer Manager":
asyncTest "getNumStreams() returns expected number of connections per protocol":
# Create 2 nodes
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<2).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))
@ -839,7 +839,7 @@ procSuite "Peer Manager":
asyncTest "colocationLimit is enforced by pruneConnsByIp()":
# Create 5 nodes
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Start them with relay + filter
await allFutures(nodes.mapIt(it.start()))

4
tests/test_waku_discv5.nim
View File

@ -23,7 +23,7 @@ proc newTestEnrRecord(privKey: libp2p_keys.PrivateKey,
flags = none(CapabilitiesBitfield)): waku_enr.Record =
var builder = EnrBuilder.init(privKey)
builder.withIpAddressAndPorts(
ipAddr = some(ValidIpAddress.init(extIp)),
ipAddr = some(parseIpAddress(extIp)),
tcpPort = some(Port(tcpPort)),
udpPort = some(Port(udpPort)),
)
@ -43,7 +43,7 @@ proc newTestDiscv5(
): WakuDiscoveryV5 =
let config = WakuDiscoveryV5Config(
privateKey: eth_keys.PrivateKey(privKey.skkey),
address: ValidIpAddress.init(bindIp),
address: parseIpAddress(bindIp),
port: Port(udpPort),
bootstrapRecords: bootstrapRecords,
)

2
tests/test_waku_dnsdisc.nim
View File

@ -25,7 +25,7 @@ suite "Waku DNS Discovery":
# Create nodes and ENR. These will be added to the discoverable list
let
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, bindIp, Port(63500))
enr1 = node1.enr

4
tests/test_waku_keepalive.nim
View File

@ -23,9 +23,9 @@ suite "Waku Keepalive":
asyncTest "handle ping keepalives":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
var completionFut = newFuture[bool]()

4
tests/test_waku_metadata.nim
View File

@ -27,8 +27,8 @@ procSuite "Waku Metadata Protocol":
asyncTest "request() returns the supported metadata of the peer":
let clusterId = 10.uint32
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0), clusterId = clusterId)
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0), clusterId = clusterId)
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), clusterId = clusterId)
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0), clusterId = clusterId)
# Start nodes
await allFutures([node1.start(), node2.start()])

18
tests/test_waku_netconfig.nim
View File

@ -32,7 +32,7 @@ suite "Waku NetConfig":
let netConfigRes = NetConfig.init(
bindIp = conf.listenAddress,
bindPort = conf.tcpPort,
extIp = none(ValidIpAddress),
extIp = none(IpAddress),
extPort = none(Port),
extMultiAddrs = @[],
wsBindPort = conf.websocketPort,
@ -68,7 +68,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
let netConfigRes = NetConfig.init(
@ -112,7 +112,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
extMultiAddrs = @[ip4TcpEndPoint(extIp, extPort)]
@ -136,7 +136,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
dns4DomainName = "example.com"
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
let netConfigRes = NetConfig.init(
@ -201,7 +201,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
wssEnabled = false
@ -254,7 +254,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
dns4DomainName = "example.com"
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
wssEnabled = false
@ -299,7 +299,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
extIp = ValidIpAddress.init("1.2.3.4")
extIp = parseIpAddress("1.2.3.4")
extPort = Port(1234)
let netConfigRes = NetConfig.init(
@ -342,7 +342,7 @@ suite "Waku NetConfig":
var
conf = defaultTestWakuNodeConf()
extAddIp = ValidIpAddress.init("1.2.3.4")
extAddIp = parseIpAddress("1.2.3.4")
extAddPort = Port(1234)
wsEnabled = true
wssEnabled = false
@ -386,7 +386,7 @@ suite "Waku NetConfig":
let
conf = defaultTestWakuNodeConf()
extAddIp = ValidIpAddress.init("1.2.3.4")
extAddIp = parseIpAddress("1.2.3.4")
extAddPort = Port(1234)
extMultiAddrs = @[ip4TcpEndPoint(extAddIp, extAddPort)]

18
tests/test_waku_peer_exchange.nim
View File

@ -81,8 +81,8 @@ procSuite "Waku Peer Exchange":
store = false,
relay = true
)
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
nodeKey1 = generateSecp256k1Key()
nodeTcpPort1 = Port(64010)
@ -193,8 +193,8 @@ procSuite "Waku Peer Exchange":
asyncTest "peer exchange request functions returns some discovered peers":
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])
@ -237,8 +237,8 @@ procSuite "Waku Peer Exchange":
asyncTest "peer exchange handler works as expected":
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])
@ -273,8 +273,8 @@ procSuite "Waku Peer Exchange":
asyncTest "peer exchange request fails gracefully":
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])
@ -296,7 +296,7 @@ procSuite "Waku Peer Exchange":
asyncTest "connections are closed after response is sent":
# Create 3 nodes
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountPeerExchange()))

40
tests/test_wakunode.nim
View File

@ -31,9 +31,9 @@ suite "WakuNode":
asyncTest "Protocol matcher works as expected":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(61000))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(61000))
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(61002))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61002))
pubSubTopic = "/waku/2/default-waku/proto"
contentTopic = ContentTopic("/waku/2/default-content/proto")
payload = "hello world".toBytes()
@ -85,9 +85,9 @@ suite "WakuNode":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(61020), nameResolver = resolver)
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(61020), nameResolver = resolver)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(61022))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61022))
# Construct DNS multiaddr for node2
let
@ -110,13 +110,13 @@ suite "WakuNode":
let
maxConnections = 2
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
Port(60010), maxConnections = maxConnections)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"),
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"),
Port(60012))
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"),
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"),
Port(60013))
check:
@ -151,7 +151,7 @@ suite "WakuNode":
expect ResultDefect:
# gibberish
discard newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
discard newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
bindPort = Port(61004),
wsBindPort = Port(8000),
wssEnabled = true,
@ -160,9 +160,9 @@ suite "WakuNode":
asyncTest "Peer info updates with correct announced addresses":
let
nodeKey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
bindPort = Port(61006)
extIp = some(ValidIpAddress.init("127.0.0.1"))
extIp = some(parseIpAddress("127.0.0.1"))
extPort = some(Port(61008))
node = newTestWakuNode(
nodeKey,
@ -199,9 +199,9 @@ suite "WakuNode":
asyncTest "Node can use dns4 in announced addresses":
let
nodeKey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
bindPort = Port(61010)
extIp = some(ValidIpAddress.init("127.0.0.1"))
extIp = some(parseIpAddress("127.0.0.1"))
extPort = some(Port(61012))
domainName = "example.com"
expectedDns4Addr = MultiAddress.init("/dns4/" & domainName & "/tcp/" & $(extPort.get())).get()
@ -218,7 +218,7 @@ suite "WakuNode":
asyncTest "Node uses dns4 resolved ip in announced addresses if no extIp is provided":
let
nodeKey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
bindPort = Port(0)
domainName = "status.im"
@ -243,7 +243,7 @@ suite "WakuNode":
asyncTest "Node creation fails when invalid dns4 address is provided":
let
nodeKey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
bindPort = Port(0)
inexistentDomain = "thisdomain.doesnot.exist"
@ -285,12 +285,12 @@ suite "WakuNode":
let
# node with custom agent string
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(61014),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(61014),
agentString = some(expectedAgentString1))
# node with default agent string from libp2p
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(61016))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61016))
await node1.start()
await node1.mountRelay()
@ -320,12 +320,12 @@ suite "WakuNode":
let
# node with custom multiaddress
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(61018),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(61018),
extMultiAddrs = @[expectedMultiaddress1])
# node with default multiaddress
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(61020))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(61020))
await node1.start()
await node1.mountRelay()
@ -345,8 +345,8 @@ suite "WakuNode":
asyncTest "Function fetchPeerExchangePeers succesfully exchanges px peers":
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
# Start and mount peer exchange
await allFutures([node1.start(), node2.start()])

4
tests/test_wakunode_filter_legacy.nim
View File

@ -22,9 +22,9 @@ suite "WakuNode - Filter":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(server.start(), client.start())

6
tests/test_wakunode_lightpush.nim
View File

@ -19,11 +19,11 @@ suite "WakuNode - Lightpush":
## Setup
let
lightNodeKey = generateSecp256k1Key()
lightNode = newTestWakuNode(lightNodeKey, ValidIpAddress.init("0.0.0.0"), Port(0))
lightNode = newTestWakuNode(lightNodeKey, parseIpAddress("0.0.0.0"), Port(0))
bridgeNodeKey = generateSecp256k1Key()
bridgeNode = newTestWakuNode(bridgeNodeKey, ValidIpAddress.init("0.0.0.0"), Port(0))
bridgeNode = newTestWakuNode(bridgeNodeKey, parseIpAddress("0.0.0.0"), Port(0))
destNodeKey = generateSecp256k1Key()
destNode = newTestWakuNode(destNodeKey, ValidIpAddress.init("0.0.0.0"), Port(0))
destNode = newTestWakuNode(destNodeKey, parseIpAddress("0.0.0.0"), Port(0))
await allFutures(destNode.start(), bridgeNode.start(), lightNode.start())

16
tests/testlib/wakunode.nim
View File

@ -25,11 +25,11 @@ proc defaultTestWakuNodeConf*(): WakuNodeConf =
cmd: noCommand,
tcpPort: Port(60000),
websocketPort: Port(8000),
listenAddress: ValidIpAddress.init("0.0.0.0"),
rpcAddress: ValidIpAddress.init("127.0.0.1"),
restAddress: ValidIpAddress.init("127.0.0.1"),
metricsServerAddress: ValidIpAddress.init("127.0.0.1"),
dnsAddrsNameServers: @[ValidIpAddress.init("1.1.1.1"), ValidIpAddress.init("1.0.0.1")],
listenAddress: parseIpAddress("0.0.0.0"),
rpcAddress: parseIpAddress("127.0.0.1"),
restAddress: parseIpAddress("127.0.0.1"),
metricsServerAddress: parseIpAddress("127.0.0.1"),
dnsAddrsNameServers: @[parseIpAddress("1.1.1.1"), parseIpAddress("1.0.0.1")],
nat: "any",
maxConnections: 50,
clusterId: 1.uint32,
@ -38,9 +38,9 @@ proc defaultTestWakuNodeConf*(): WakuNodeConf =
)
proc newTestWakuNode*(nodeKey: crypto.PrivateKey,
bindIp: ValidIpAddress,
bindIp: IpAddress,
bindPort: Port,
extIp = none(ValidIpAddress),
extIp = none(IpAddress),
extPort = none(Port),
extMultiAddrs = newSeq[MultiAddress](),
peerStorage: PeerStorage = nil,
@ -77,7 +77,7 @@ proc newTestWakuNode*(nodeKey: crypto.PrivateKey,
let dns = (waitFor dnsResolve(dns4DomainName.get(), conf)).valueOr:
raise newException(Defect, error)
resolvedExtIp = some(ValidIpAddress.init(dns))
resolvedExtIp = some(parseIpAddress(dns))
let netConf = NetConfig.init(
bindIp = bindIp,

4
tests/waku_core/test_published_address.nim
View File

@ -12,7 +12,7 @@ suite "Waku Core - Published Address":
test "Test IP 0.0.0.0":
let
node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init(
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress(
"0.0.0.0"),Port(0))
check:
@ -20,7 +20,7 @@ suite "Waku Core - Published Address":
test "Test custom IP":
let
node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init(
node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress(
"8.8.8.8"),Port(0))
check:

42
tests/waku_relay/test_wakunode_relay.nim
View File

@ -27,7 +27,7 @@ suite "WakuNode - Relay":
asyncTest "Relay protocol is started correctly":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay protocol starts if mounted after node start
@ -41,7 +41,7 @@ suite "WakuNode - Relay":
let
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
await node2.mountRelay()
@ -60,11 +60,11 @@ suite "WakuNode - Relay":
asyncTest "Messages are correctly relayed":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
pubSubTopic = "test"
contentTopic = ContentTopic("/waku/2/default-content/proto")
payload = "hello world".toBytes()
@ -115,13 +115,13 @@ suite "WakuNode - Relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
pubSubTopic = "test"
contentTopic1 = ContentTopic("/waku/2/default-content/proto")
@ -195,7 +195,7 @@ suite "WakuNode - Relay":
# TODO: Add a function to validate the WakuMessage integrity
xasyncTest "Stats of peer sending wrong WakuMessages are updated":
# Create 2 nodes
let nodes = toSeq(0..1).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..1).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Start all the nodes and mount relay with
await allFutures(nodes.mapIt(it.start()))
@ -228,10 +228,10 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between two websocket nodes":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
bindPort = Port(0), wsBindPort = Port(0), wsEnabled = true)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"),
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"),
bindPort = Port(0), wsBindPort = Port(0), wsEnabled = true)
pubSubTopic = "test"
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -269,10 +269,10 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between nodes with multiple transports (TCP and Websockets)":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
bindPort = Port(0), wsBindPort = Port(0), wsEnabled = true)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"),
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"),
bindPort = Port(0))
pubSubTopic = "test"
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -310,10 +310,10 @@ suite "WakuNode - Relay":
asyncTest "Messages relaying fails with non-overlapping transports (TCP or Websockets)":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
bindPort = Port(0))
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"),
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"),
bindPort = Port(0), wsBindPort = Port(0), wsEnabled = true)
pubSubTopic = "test"
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -354,10 +354,10 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between nodes with multiple transports (TCP and secure Websockets)":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"),
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"),
bindPort = Port(0), wsBindPort = Port(0), wssEnabled = true, secureKey = KEY_PATH, secureCert = CERT_PATH)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"),
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"),
bindPort = Port(0))
pubSubTopic = "test"
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -394,9 +394,9 @@ suite "WakuNode - Relay":
asyncTest "Messages are relayed between nodes with multiple transports (websocket and secure Websockets)":
let
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), bindPort = Port(0), wsBindPort = Port(0), wssEnabled = true, secureKey = KEY_PATH, secureCert = CERT_PATH)
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), bindPort = Port(0), wsBindPort = Port(0), wssEnabled = true, secureKey = KEY_PATH, secureCert = CERT_PATH)
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), bindPort = Port(0),wsBindPort = Port(0), wsEnabled = true )
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), bindPort = Port(0),wsBindPort = Port(0), wsEnabled = true )
let
pubSubTopic = "test"
@ -434,7 +434,7 @@ suite "WakuNode - Relay":
asyncTest "Bad peers with low reputation are disconnected":
# Create 5 nodes
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -487,7 +487,7 @@ suite "WakuNode - Relay":
## Setup
let
nodeKey = generateSecp256k1Key()
node = newTestWakuNode(nodeKey, ValidIpAddress.init("0.0.0.0"), Port(0))
node = newTestWakuNode(nodeKey, parseIpAddress("0.0.0.0"), Port(0))
await node.start()
await node.mountRelay()

150
tests/waku_rln_relay/test_rln_group_manager_onchain.nim
View File

@ -133,7 +133,7 @@ proc runGanache(): Process =
ganacheStartLog.add(cmdline)
if cmdline.contains("Listening on 127.0.0.1:8540"):
break
except CatchableError:
except Exception, CatchableError:
break
debug "Ganache daemon is running and ready", pid=ganachePID, startLog=ganacheStartLog
return runGanache
@ -221,14 +221,22 @@ suite "Onchain group manager":
let manager = await setup()
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
await manager.stop()
asyncTest "startGroupSync: should guard against uninitialized state":
let manager = await setup()
expect(ValueError):
try:
await manager.startGroupSync()
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
await manager.stop()
asyncTest "startGroupSync: should sync to the state of the group":
@ -252,10 +260,12 @@ suite "Onchain group manager":
fut.complete()
return callback
manager.onRegister(generateCallback(fut))
await manager.register(credentials)
await manager.startGroupSync()
try:
manager.onRegister(generateCallback(fut))
await manager.register(credentials)
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
@ -292,11 +302,15 @@ suite "Onchain group manager":
futs[futureIndex].complete()
futureIndex += 1
return callback
manager.onRegister(generateCallback(futures, credentials))
await manager.startGroupSync()
for i in 0 ..< credentials.len():
await manager.register(credentials[i])
try:
manager.onRegister(generateCallback(futures, credentials))
await manager.startGroupSync()
for i in 0 ..< credentials.len():
await manager.register(credentials[i])
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await allFutures(futures)
@ -314,21 +328,34 @@ suite "Onchain group manager":
let manager = await setup()
let dummyCommitment = default(IDCommitment)
expect(ValueError):
try:
await manager.register(dummyCommitment)
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await manager.stop()
asyncTest "register: should register successfully":
let manager = await setup()
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
let idCommitment = generateCredentials(manager.rlnInstance).idCommitment
let merkleRootBeforeRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootBeforeRes.isOk()
let merkleRootBefore = merkleRootBeforeRes.get()
await manager.register(idCommitment)
try:
await manager.register(idCommitment)
except Exception, CatchableError:
assert false, "exception raised when calling register: " & getCurrentExceptionMsg()
let merkleRootAfterRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootAfterRes.isOk()
@ -354,9 +381,11 @@ suite "Onchain group manager":
manager.onRegister(callback)
await manager.init()
await manager.startGroupSync()
await manager.register(idCommitment)
try:
await manager.startGroupSync()
await manager.register(idCommitment)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
@ -368,8 +397,13 @@ suite "Onchain group manager":
let manager = await setup()
let idSecretHash = generateCredentials(manager.rlnInstance).idSecretHash
expect(ValueError):
try:
await manager.withdraw(idSecretHash)
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await manager.stop()
asyncTest "validateRoot: should validate good root":
@ -390,8 +424,12 @@ suite "Onchain group manager":
manager.onRegister(callback)
await manager.startGroupSync()
await manager.register(credentials)
try:
await manager.startGroupSync()
await manager.register(credentials)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
let messageBytes = "Hello".toBytes()
@ -417,7 +455,10 @@ suite "Onchain group manager":
asyncTest "validateRoot: should reject bad root":
let manager = await setup()
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
let credentials = generateCredentials(manager.rlnInstance)
@ -462,8 +503,11 @@ suite "Onchain group manager":
manager.onRegister(callback)
await manager.startGroupSync()
await manager.register(credentials)
try:
await manager.startGroupSync()
await manager.register(credentials)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
let messageBytes = "Hello".toBytes()
@ -491,10 +535,17 @@ suite "Onchain group manager":
asyncTest "verifyProof: should reject invalid proof":
let manager = await setup()
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
let idCredential = generateCredentials(manager.rlnInstance)
await manager.register(idCredential.idCommitment)
try:
await manager.register(idCredential.idCommitment)
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
let idCredential2 = generateCredentials(manager.rlnInstance)
@ -546,11 +597,13 @@ suite "Onchain group manager":
futureIndex += 1
return callback
manager.onRegister(generateCallback(futures, credentials))
await manager.startGroupSync()
for i in 0 ..< credentials.len():
await manager.register(credentials[i])
try:
manager.onRegister(generateCallback(futures, credentials))
await manager.startGroupSync()
for i in 0 ..< credentials.len():
await manager.register(credentials[i])
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await allFutures(futures)
@ -561,7 +614,10 @@ suite "Onchain group manager":
# We can now simulate a chain reorg by calling backfillRootQueue
let expectedLastRoot = manager.validRootBuffer[0]
await manager.backfillRootQueue(1)
try:
await manager.backfillRootQueue(1)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
# We should now have 5 roots in the queue, and no partial buffer
check:
@ -576,26 +632,50 @@ suite "Onchain group manager":
manager.ethRpc = none(Web3)
var isReady = true
try:
isReady = await manager.isReady()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
check:
(await manager.isReady()) == false
isReady == false
await manager.stop()
asyncTest "isReady should return false if lastSeenBlockHead > lastProcessed":
var manager = await setup()
await manager.init()
var isReady = true
try:
isReady = await manager.isReady()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
check:
(await manager.isReady()) == false
isReady == false
await manager.stop()
asyncTest "isReady should return true if ethRpc is ready":
var manager = await setup()
await manager.init()
# node can only be ready after group sync is done
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
var isReady = false
try:
isReady = await manager.isReady()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
check:
(await manager.isReady()) == true
isReady == true
await manager.stop()

68
tests/waku_rln_relay/test_rln_group_manager_static.nim
View File

@ -73,16 +73,23 @@ suite "Static group manager":
require:
manager.validRoots.len() == 1
manager.rlnInstance.getMerkleRoot().get() == manager.validRoots[0]
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
asyncTest "startGroupSync: should guard against uninitialized state":
let manager = StaticGroupManager(groupSize: 0,
membershipIndex: some(MembershipIndex(0)),
groupKeys: @[],
rlnInstance: rlnInstance)
expect(ValueError):
try:
await manager.startGroupSync()
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised when calling startGroupSync: " & getCurrentExceptionMsg()
asyncTest "register: should guard against uninitialized state":
let manager = StaticGroupManager(groupSize: 0,
@ -92,19 +99,29 @@ suite "Static group manager":
let dummyCommitment = default(IDCommitment)
expect(ValueError):
try:
await manager.register(dummyCommitment)
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
asyncTest "register: should register successfully":
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
let idCommitment = generateCredentials(manager.rlnInstance).idCommitment
let merkleRootBeforeRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootBeforeRes.isOk()
let merkleRootBefore = merkleRootBeforeRes.get()
await manager.register(idCommitment)
try:
await manager.register(idCommitment)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
let merkleRootAfterRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootAfterRes.isOk()
@ -127,11 +144,13 @@ suite "Static group manager":
callbackCalled = true
fut.complete()
manager.onRegister(callback)
await manager.init()
await manager.startGroupSync()
await manager.register(idCommitment)
try:
manager.onRegister(callback)
await manager.init()
await manager.startGroupSync()
await manager.register(idCommitment)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
check:
@ -140,19 +159,29 @@ suite "Static group manager":
asyncTest "withdraw: should guard against uninitialized state":
let idSecretHash = credentials[0].idSecretHash
expect(ValueError):
try:
await manager.withdraw(idSecretHash)
except ValueError:
assert true
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
asyncTest "withdraw: should withdraw successfully":
await manager.init()
await manager.startGroupSync()
try:
await manager.startGroupSync()
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
let idSecretHash = credentials[0].idSecretHash
let merkleRootBeforeRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootBeforeRes.isOk()
let merkleRootBefore = merkleRootBeforeRes.get()
await manager.withdraw(idSecretHash)
try:
await manager.withdraw(idSecretHash)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
let merkleRootAfterRes = manager.rlnInstance.getMerkleRoot()
require:
merkleRootAfterRes.isOk()
@ -174,11 +203,14 @@ suite "Static group manager":
callbackCalled = true
fut.complete()
manager.onWithdraw(callback)
await manager.init()
await manager.startGroupSync()
try:
manager.onWithdraw(callback)
await manager.init()
await manager.startGroupSync()
await manager.withdraw(idSecretHash)
await manager.withdraw(idSecretHash)
except Exception, CatchableError:
assert false, "exception raised: " & getCurrentExceptionMsg()
await fut
check:

26
tests/waku_rln_relay/test_wakunode_rln_relay.nim
View File

@ -24,13 +24,13 @@ procSuite "WakuNode - RLN relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -105,7 +105,7 @@ procSuite "WakuNode - RLN relay":
asyncTest "testing rln-relay is applied in all rln pubsub/content topics":
# create 3 nodes
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
await allFutures(nodes.mapIt(it.start()))
let pubsubTopics = @[
@ -183,13 +183,13 @@ procSuite "WakuNode - RLN relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -282,13 +282,13 @@ procSuite "WakuNode - RLN relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
contentTopic = ContentTopic("/waku/2/default-content/proto")
@ -402,13 +402,13 @@ procSuite "WakuNode - RLN relay":
let
# publisher node
nodeKey1 = generateSecp256k1Key()
node1 = newTestWakuNode(nodeKey1, ValidIpAddress.init("0.0.0.0"), Port(0))
node1 = newTestWakuNode(nodeKey1, parseIpAddress("0.0.0.0"), Port(0))
# Relay node
nodeKey2 = generateSecp256k1Key()
node2 = newTestWakuNode(nodeKey2, ValidIpAddress.init("0.0.0.0"), Port(0))
node2 = newTestWakuNode(nodeKey2, parseIpAddress("0.0.0.0"), Port(0))
# Subscriber
nodeKey3 = generateSecp256k1Key()
node3 = newTestWakuNode(nodeKey3, ValidIpAddress.init("0.0.0.0"), Port(0))
node3 = newTestWakuNode(nodeKey3, parseIpAddress("0.0.0.0"), Port(0))
contentTopic = ContentTopic("/waku/2/default-content/proto")

8
tests/waku_store/test_resume.nim
View File

@ -194,9 +194,9 @@ suite "WakuNode - waku store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
await allFutures(client.start(), server.start())
@ -228,9 +228,9 @@ suite "WakuNode - waku store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
await allFutures(server.start(), client.start())
await server.mountStore(store=StoreQueueRef.new())

22
tests/waku_store/test_wakunode_store.nim
View File

@ -59,9 +59,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(client.start(), server.start())
@ -93,9 +93,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(client.start(), server.start())
@ -144,9 +144,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(client.start(), server.start())
@ -196,11 +196,11 @@ procSuite "WakuNode - Store":
## Setup
let
filterSourceKey = generateSecp256k1Key()
filterSource = newTestWakuNode(filterSourceKey, ValidIpAddress.init("0.0.0.0"), Port(0))
filterSource = newTestWakuNode(filterSourceKey, parseIpAddress("0.0.0.0"), Port(0))
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(client.start(), server.start(), filterSource.start())
@ -257,9 +257,9 @@ procSuite "WakuNode - Store":
## Setup
let
serverKey = generateSecp256k1Key()
server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
clientKey = generateSecp256k1Key()
client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(0))
waitFor allFutures(client.start(), server.start())

6
tests/wakunode2/test_validators.nim
View File

@ -25,7 +25,7 @@ suite "WakuNode2 - Validators":
asyncTest "Spam protected topic accepts signed messages":
# Create 5 nodes
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Protected topic and key to sign
let spamProtectedTopic = PubSubTopic("some-spam-protected-topic")
@ -94,7 +94,7 @@ suite "WakuNode2 - Validators":
asyncTest "Spam protected topic rejects non-signed/wrongly-signed/no-timestamp messages":
# Create 5 nodes
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Protected topic and key to sign
let spamProtectedTopic = PubSubTopic("some-spam-protected-topic")
@ -204,7 +204,7 @@ suite "WakuNode2 - Validators":
asyncTest "Spam protected topic rejects a spammer node":
# Create 5 nodes
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)))
let nodes = toSeq(0..<5).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0)))
# Protected topic and key to sign
let spamProtectedTopic = PubSubTopic("some-spam-protected-topic")

12
tests/wakunode_jsonrpc/test_jsonrpc_admin.nim
View File

@ -26,15 +26,15 @@ import
procSuite "Waku v2 JSON-RPC API - Admin":
let
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
asyncTest "connect to ad-hoc peers":
# Create a couple of nodes
let
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60600))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60602))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60600))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60602))
peerInfo2 = node2.switch.peerInfo
node3 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60604))
node3 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60604))
peerInfo3 = node3.switch.peerInfo
await allFutures([node1.start(), node2.start(), node3.start()])
@ -90,7 +90,7 @@ procSuite "Waku v2 JSON-RPC API - Admin":
asyncTest "get managed peer information":
# Create 3 nodes and start them with relay
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60220+it*2)))
let nodes = toSeq(0..<3).mapIt(newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60220+it*2)))
await allFutures(nodes.mapIt(it.start()))
await allFutures(nodes.mapIt(it.mountRelay()))
@ -137,7 +137,7 @@ procSuite "Waku v2 JSON-RPC API - Admin":
await allFutures(nodes.mapIt(it.stop()))
asyncTest "get unmanaged peer information":
let node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(60523))
let node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(60523))
await node.start()

4
tests/wakunode_jsonrpc/test_jsonrpc_debug.nim
View File

@ -21,8 +21,8 @@ import
procSuite "Waku v2 JSON-RPC API - Debug":
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
node = newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))

2
tests/wakunode_jsonrpc/test_jsonrpc_filter.nim
View File

@ -20,7 +20,7 @@ import
procSuite "Waku v2 JSON-RPC API - Filter":
let
bindIp = ValidIpAddress.init("0.0.0.0")
bindIp = parseIpAddress("0.0.0.0")
asyncTest "subscribe and unsubscribe":
let

22
tests/wakunode_jsonrpc/test_jsonrpc_relay.nim
View File

@ -23,7 +23,7 @@ suite "Waku v2 JSON-RPC API - Relay":
asyncTest "subscribe and unsubscribe from topics":
## Setup
let node = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
let node = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
await node.start()
await node.mountRelay(@[])
@ -31,7 +31,7 @@ suite "Waku v2 JSON-RPC API - Relay":
# JSON-RPC server
let
rpcPort = Port(8547)
ta = initTAddress(ValidIpAddress.init("0.0.0.0"), rpcPort)
ta = initTAddress(parseIpAddress("0.0.0.0"), rpcPort)
server = newRpcHttpServer([ta])
let cache = MessageCache.init(capacity=30)
@ -84,8 +84,8 @@ suite "Waku v2 JSON-RPC API - Relay":
# Relay nodes setup
let
srcNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
srcNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
await allFutures(srcNode.start(), dstNode.start())
@ -105,7 +105,7 @@ suite "Waku v2 JSON-RPC API - Relay":
# RPC server (source node)
let
rpcPort = Port(8548)
ta = initTAddress(ValidIpAddress.init("0.0.0.0"), rpcPort)
ta = initTAddress(parseIpAddress("0.0.0.0"), rpcPort)
server = newRpcHttpServer([ta])
let cache = MessageCache.init(capacity=30)
@ -162,8 +162,8 @@ suite "Waku v2 JSON-RPC API - Relay":
# Relay nodes setup
let
srcNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
srcNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
await allFutures(srcNode.start(), dstNode.start())
@ -175,7 +175,7 @@ suite "Waku v2 JSON-RPC API - Relay":
# RPC server (destination node)
let
rpcPort = Port(8549)
ta = initTAddress(ValidIpAddress.init("0.0.0.0"), rpcPort)
ta = initTAddress(parseIpAddress("0.0.0.0"), rpcPort)
server = newRpcHttpServer([ta])
let cache = MessageCache.init(capacity=30)
@ -223,8 +223,8 @@ suite "Waku v2 JSON-RPC API - Relay":
# Relay nodes setup
let
srcNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0))
srcNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
dstNode = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("0.0.0.0"), Port(0))
await allFutures(srcNode.start(), dstNode.start())
@ -238,7 +238,7 @@ suite "Waku v2 JSON-RPC API - Relay":
# RPC server (destination node)
let
rpcPort = Port(8550)
ta = initTAddress(ValidIpAddress.init("0.0.0.0"), rpcPort)
ta = initTAddress(parseIpAddress("0.0.0.0"), rpcPort)
server = newRpcHttpServer([ta])
let cache = MessageCache.init(capacity=30)

14
tests/wakunode_jsonrpc/test_jsonrpc_store.nim
View File

@ -37,8 +37,8 @@ procSuite "Waku v2 JSON-RPC API - Store":
asyncTest "query a node and retrieve historical messages":
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
node = newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -110,8 +110,8 @@ procSuite "Waku v2 JSON-RPC API - Store":
asyncTest "check error response when peer-store-node is not available":
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
node = newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -154,7 +154,11 @@ procSuite "Waku v2 JSON-RPC API - Store":
some(Timestamp(9)),
some(StorePagingOptions()))
except ValueError:
jsonError = parseJson(getCurrentExceptionMsg())
try:
jsonError = parseJson(getCurrentExceptionMsg())
except Exception:
assert false, "exception calling parseJson: " & getCurrentExceptionMsg()
check:
$jsonError["code"] == "-32000"

8
tests/wakunode_rest/test_rest_admin.nim
View File

@ -32,17 +32,17 @@ suite "Waku v2 Rest API - Admin":
var client{.threadvar.}: RestClientRef
asyncSetup:
node1 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60600))
node2 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60602))
node1 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60600))
node2 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60602))
peerInfo2 = node2.switch.peerInfo
node3 = newTestWakuNode(generateSecp256k1Key(), ValidIpAddress.init("127.0.0.1"), Port(60604))
node3 = newTestWakuNode(generateSecp256k1Key(), parseIpAddress("127.0.0.1"), Port(60604))
peerInfo3 = node3.switch.peerInfo
await allFutures(node1.start(), node2.start(), node3.start())
await allFutures(node1.mountRelay(), node2.mountRelay(), node3.mountRelay())
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("127.0.0.1")
let restAddress = parseIpAddress("127.0.0.1")
restServer = RestServerRef.init(restAddress, restPort).tryGet()
installAdminApiHandlers(restServer.router, node1)

8
tests/wakunode_rest/test_rest_debug.nim
View File

@ -24,8 +24,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = crypto.PrivateKey.random(Secp256k1, rng[]).tryGet()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(58000)
newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -39,7 +39,7 @@ suite "Waku v2 REST API - Debug":
await node.mountRelay()
let restPort = Port(58001)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installDebugApiHandlers(restServer.router, node)
@ -66,7 +66,7 @@ suite "Waku v2 REST API - Debug":
await node.mountRelay()
let restPort = Port(58002)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installDebugApiHandlers(restServer.router, node)

6
tests/wakunode_rest/test_rest_filter.nim
View File

@ -30,8 +30,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
return newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -61,7 +61,7 @@ proc init(T: type RestFilterTest): Future[T] {.async.} =
testSetup.subscriberNode.peerManager.addServicePeer(testSetup.serviceNode.peerInfo.toRemotePeerInfo(), WakuFilterSubscribeCodec)
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("127.0.0.1")
let restAddress = parseIpAddress("127.0.0.1")
testSetup.restServer = RestServerRef.init(restAddress, restPort).tryGet()
let restPort2 = Port(58012)

6
tests/wakunode_rest/test_rest_health.nim
View File

@ -27,8 +27,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = crypto.PrivateKey.random(Secp256k1, rng[]).tryGet()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -43,7 +43,7 @@ suite "Waku v2 REST API - health":
await node.mountRelay()
let restPort = Port(58001)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installHealthApiHandler(restServer.router, node)

6
tests/wakunode_rest/test_rest_legacy_filter.nim
View File

@ -28,8 +28,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
return newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -56,7 +56,7 @@ proc setupRestFilter(): Future[RestFilterTest] {.async.} =
,WakuLegacyFilterCodec)
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
result.restServer = RestServerRef.init(restAddress, restPort).tryGet()
result.messageCache = MessageCache.init()

6
tests/wakunode_rest/test_rest_lightpush.nim
View File

@ -28,8 +28,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
return newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -70,7 +70,7 @@ proc init(T: type RestLightPushTest): Future[T] {.async.} =
WakuLightPushCodec)
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("127.0.0.1")
let restAddress = parseIpAddress("127.0.0.1")
testSetup.restServer = RestServerRef.init(restAddress, restPort).tryGet()
installLightPushRequestHandler(testSetup.restServer.router, testSetup.pushNode)

20
tests/wakunode_rest/test_rest_relay.nim
View File

@ -26,8 +26,8 @@ import
proc testWakuNode(): WakuNode =
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -41,7 +41,7 @@ suite "Waku v2 Rest API - Relay":
await node.mountRelay()
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let cache = MessageCache.init()
@ -89,7 +89,7 @@ suite "Waku v2 Rest API - Relay":
])
let restPort = Port(58012)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let cache = MessageCache.init()
@ -141,7 +141,7 @@ suite "Waku v2 Rest API - Relay":
await node.mountRelay()
let restPort = Port(58013)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let pubSubTopic = "/waku/2/default-waku/proto"
@ -204,7 +204,7 @@ suite "Waku v2 Rest API - Relay":
# RPC server setup
let restPort = Port(58014)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let cache = MessageCache.init()
@ -244,7 +244,7 @@ suite "Waku v2 Rest API - Relay":
await node.mountRelay()
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let cache = MessageCache.init()
@ -290,7 +290,7 @@ suite "Waku v2 Rest API - Relay":
await node.mountRelay()
let restPort = Port(58012)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let contentTopics = @[
@ -336,7 +336,7 @@ suite "Waku v2 Rest API - Relay":
await node.mountRelay()
let restPort = Port(58013)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let contentTopic = DefaultContentTopic
@ -398,7 +398,7 @@ suite "Waku v2 Rest API - Relay":
# RPC server setup
let restPort = Port(58014)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
let cache = MessageCache.init()

16
tests/wakunode_rest/test_rest_store.nim
View File

@ -44,8 +44,8 @@ proc put(store: ArchiveDriver, pubsubTopic: PubsubTopic, message: WakuMessage):
proc testWakuNode(): WakuNode =
let
privkey = generateSecp256k1Key()
bindIp = ValidIpAddress.init("0.0.0.0")
extIp = ValidIpAddress.init("127.0.0.1")
bindIp = parseIpAddress("0.0.0.0")
extIp = parseIpAddress("127.0.0.1")
port = Port(0)
return newTestWakuNode(privkey, bindIp, port, some(extIp), some(port))
@ -81,7 +81,7 @@ procSuite "Waku v2 Rest API - Store":
await node.mountRelay()
let restPort = Port(58011)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)
@ -151,7 +151,7 @@ procSuite "Waku v2 Rest API - Store":
await node.start()
let restPort = Port(58012)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)
@ -249,7 +249,7 @@ procSuite "Waku v2 Rest API - Store":
await node.mountRelay()
let restPort = Port(58013)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)
@ -323,7 +323,7 @@ procSuite "Waku v2 Rest API - Store":
await node.mountRelay()
let restPort = Port(58014)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)
@ -414,7 +414,7 @@ procSuite "Waku v2 Rest API - Store":
await node.mountRelay()
let restPort = Port(58015)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)
@ -471,7 +471,7 @@ procSuite "Waku v2 Rest API - Store":
await node.mountRelay()
let restPort = Port(58016)
let restAddress = ValidIpAddress.init("0.0.0.0")
let restAddress = parseIpAddress("0.0.0.0")
let restServer = RestServerRef.init(restAddress, restPort).tryGet()
installStoreApiHandlers(restServer.router, node)

2
tools/rln_keystore_generator/rln_keystore_generator.nim
View File

@ -64,7 +64,7 @@ proc doRlnKeystoreGenerator*(conf: WakuNodeConf) =
# 5. register on-chain
try:
waitFor groupManager.register(credential)
except CatchableError:
except Exception, CatchableError:
error "failure while registering credentials on-chain", error=getCurrentExceptionMsg()
quit(1)

2
vendor/nim-chronicles vendored

@ -1 +1 @@
Subproject commit d1d34b9490f99fa2052ffcff2bcf0edaf42d1bdd
Subproject commit ccbb7566d1a06bfc1ec42dd8da74a47f1d3b3f4b

2
vendor/nim-chronos vendored

@ -1 +1 @@
Subproject commit be2edab3ac101da03a70cbf52bc3f3d972b35d91
Subproject commit e38ceb5378e7ce945eedbe1c6fb670095cfb9cc5

2
vendor/nim-dnsdisc vendored

@ -1 +1 @@
Subproject commit ddef6f88de5fdd9874f62415e14ea437d8fb9e5d
Subproject commit 302dfde46fa72a4e0de58a3dbdf54f5a77350816

2
vendor/nim-eth vendored

@ -1 +1 @@
Subproject commit 700360fde2cf91c0c6d66af42851ee21c947e23a
Subproject commit e5c2b1784ec7badc6162325e37daee2229f53d8b

2
vendor/nim-http-utils vendored

@ -1 +1 @@
Subproject commit 4a46dcc4c0c6c4a53715602d4cfd47a032ab8582
Subproject commit 77a59297ad635d91a6352ef48ee09c6bde0c5d86

2
vendor/nim-libp2p vendored

@ -1 +1 @@
Subproject commit fc4e9a8bb869428618ee37c6525e670859cfdaf3
Subproject commit 3011ba4326fa55220a758838835797ff322619fc

2
vendor/nim-stew vendored

@ -1 +1 @@
Subproject commit 3159137d9a3110edb4024145ce0ba778975de40e
Subproject commit 2c2544aec13536304438be045bfdd22452741466

2
vendor/nim-unittest2 vendored

@ -1 +1 @@
Subproject commit 91973dfa3823a8b423abdce59ac19de0a17ef9c1
Subproject commit 262b697f38d6b6f1e7462d3b3ab81d79b894e336

4
waku/common/confutils/envvar/std/net.nim
View File

@ -13,9 +13,9 @@ export
net,
envvar_serialization
proc readValue*(r: var EnvvarReader, value: var ValidIpAddress) {.raises: [SerializationError].} =
proc readValue*(r: var EnvvarReader, value: var IpAddress) {.raises: [SerializationError].} =
try:
value = ValidIpAddress.init(r.readValue(string))
value = parseIpAddress(r.readValue(string))
except ValueError, IOError:
raise newException(SerializationError, "Invalid IP address: " & getCurrentExceptionMsg())

8
waku/common/databases/db_postgres/dbconn.nim
View File

@ -1,7 +1,3 @@
when (NimMajor, NimMinor) < (1, 4):
{.push raises: [Defect,DbError].}
else:
{.push raises: [ValueError,DbError].}
import
std/[times, strutils, strformat],
@ -10,7 +6,7 @@ import
include db_postgres
type DataProc* = proc(result: ptr PGresult) {.closure, gcsafe.}
type DataProc* = proc(result: ptr PGresult) {.closure, gcsafe, raises: [].}
## Connection management
@ -80,7 +76,7 @@ proc sendQueryPrepared(
paramValues: openArray[string],
paramLengths: openArray[int32],
paramFormats: openArray[int32]):
Result[void, string] =
Result[void, string] {.raises: [].} =
## This proc can be used directly for queries that don't retrieve values back.
if paramValues.len != paramLengths.len or paramValues.len != paramFormats.len or

6
waku/common/enr/builder.nim
View File

@ -51,7 +51,7 @@ proc build*(builder: EnrBuilder): EnrResult[enr.Record] =
enr.Record.init(
seqNum = builder.seqNumber,
pk = builder.privateKey,
ip = none(ValidIpAddress),
ip = none(IpAddress),
tcpPort = none(Port),
udpPort = none(Port),
extraFields = builder.fields
@ -60,7 +60,7 @@ proc build*(builder: EnrBuilder): EnrResult[enr.Record] =
## Builder extension: IP address and TCP/UDP ports
proc addAddressAndPorts(builder: var EnrBuilder, ip: ValidIpAddress, tcpPort, udpPort: Option[Port]) =
proc addAddressAndPorts(builder: var EnrBuilder, ip: IpAddress, tcpPort, udpPort: Option[Port]) =
# Based on: https://github.com/status-im/nim-eth/blob/4b22fcd/eth/p2p/discoveryv5/enr.nim#L166
let isV6 = ip.family == IPv6
@ -93,7 +93,7 @@ proc addPorts(builder: var EnrBuilder, tcp, udp: Option[Port]) =
proc withIpAddressAndPorts*(builder: var EnrBuilder,
ipAddr = none(ValidIpAddress),
ipAddr = none(IpAddress),
tcpPort = none(Port),
udpPort = none(Port)) =
if ipAddr.isSome():

8
waku/common/utils/nat.nim
View File

@ -18,7 +18,7 @@ logScope:
proc setupNat*(natConf, clientId: string,
tcpPort, udpPort: Port):
Result[tuple[ip: Option[ValidIpAddress],
Result[tuple[ip: Option[IpAddress],
tcpPort: Option[Port],
udpPort: Option[Port]], string]
{.gcsafe.} =
@ -30,12 +30,12 @@ proc setupNat*(natConf, clientId: string,
of "pmp": NatPmp
else: NatNone
var endpoint: tuple[ip: Option[ValidIpAddress], tcpPort: Option[Port], udpPort: Option[Port]]
var endpoint: tuple[ip: Option[IpAddress], tcpPort: Option[Port], udpPort: Option[Port]]
if strategy != NatNone:
let extIp = getExternalIP(strategy)
if extIP.isSome():
endpoint.ip = some(ValidIpAddress.init(extIp.get()))
endpoint.ip = some(extIp.get())
# RedirectPorts in considered a gcsafety violation
# because it obtains the address of a non-gcsafe proc?
var extPorts: Option[(Port, Port)]
@ -59,7 +59,7 @@ proc setupNat*(natConf, clientId: string,
try:
# any required port redirection is assumed to be done by hand
endpoint.ip = some(ValidIpAddress.init(natConf[6..^1]))
endpoint.ip = some(parseIpAddress(natConf[6..^1]))
except ValueError:
return err("not a valid IP address: " & $natConf[6..^1])

4
waku/node/builder.nim
View File

@ -68,9 +68,9 @@ proc withNetworkConfiguration*(builder: var WakuNodeBuilder, config: NetConfig)
builder.netConfig = some(config)
proc withNetworkConfigurationDetails*(builder: var WakuNodeBuilder,
bindIp: ValidIpAddress,
bindIp: IpAddress,
bindPort: Port,
extIp = none(ValidIpAddress),
extIp = none(IpAddress),
extPort = none(Port),
extMultiAddrs = newSeq[MultiAddress](),
wsBindPort: Port = Port(8000),

10
waku/node/config.nim
View File

@ -21,17 +21,17 @@ type NetConfig* = object
hostExtAddress*: Option[MultiAddress]
wsExtAddress*: Option[MultiAddress]
wssEnabled*: bool
extIp*: Option[ValidIpAddress]
extIp*: Option[IpAddress]
extPort*: Option[Port]
dns4DomainName*: Option[string]
announcedAddresses*: seq[MultiAddress]
extMultiAddrs*: seq[MultiAddress]
enrMultiAddrs*: seq[MultiAddress]
enrIp*: Option[ValidIpAddress]
enrIp*: Option[IpAddress]
enrPort*: Option[Port]
discv5UdpPort*: Option[Port]
wakuFlags*: Option[CapabilitiesBitfield]
bindIp*: ValidIpAddress
bindIp*: IpAddress
bindPort*: Port
type NetConfigResult* = Result[NetConfig, string]
@ -70,9 +70,9 @@ proc containsWsAddress(extMultiAddrs: seq[MultiAddress]): bool =
return extMultiAddrs.filterIt( it.isWsAddress() ).len > 0
proc init*(T: type NetConfig,
bindIp: ValidIpAddress,
bindIp: IpAddress,
bindPort: Port,
extIp = none(ValidIpAddress),
extIp = none(IpAddress),
extPort = none(Port),
extMultiAddrs = newSeq[MultiAddress](),
extMultiAddrsOnly: bool = false,

7
waku/node/waku_node.nim
View File

@ -1160,14 +1160,17 @@ proc stop*(node: WakuNode) {.async.} =
node.peerManager.stop()
if not node.wakuRlnRelay.isNil():
await node.wakuRlnRelay.stop()
try:
await node.wakuRlnRelay.stop() ## this can raise an exception
except Exception:
error "exception stopping the node", error=getCurrentExceptionMsg()
if not node.wakuArchive.isNil():
await node.wakuArchive.stop()
node.started = false
proc isReady*(node: WakuNode): Future[bool] {.async.} =
proc isReady*(node: WakuNode): Future[bool] {.async: (raises: [Exception]).} =
if node.wakuRlnRelay == nil:
return true
return await node.wakuRlnRelay.isReady()

10
waku/waku_api/rest/health/handlers.nim
View File

@ -35,8 +35,12 @@ proc installHealthApiHandler*(router: var RestRouter, node: WakuNode) =
var msg = "Node is healthy"
var status = Http200
if not isReadyStateFut.read():
msg = "Node is not ready"
status = Http503
try:
if not isReadyStateFut.read():
msg = "Node is not ready"
status = Http503
except:
msg = "exception reading state: " & getCurrentExceptionMsg()
status = Http500
return RestApiResponse.textResponse(msg, status)

4
waku/waku_api/rest/server.nim
View File

@ -57,7 +57,7 @@ proc getRouter(allowedOrigin: Option[string]): RestRouter =
RestRouter.init(validate, allowedOrigin = allowedOrigin)
proc init*(T: type RestServerRef,
ip: ValidIpAddress, port: Port,
ip: IpAddress, port: Port,
allowedOrigin=none(string),
conf=RestServerConf.default(),
requestErrorHandler: RestRequestErrorHandler = nil): RestServerResult[T] =
@ -92,7 +92,7 @@ proc init*(T: type RestServerRef,
# RestResult error type is cstring, so we need to map it to string
res.mapErr(proc(err: cstring): string = $err)
proc newRestHttpServer*(ip: ValidIpAddress, port: Port,
proc newRestHttpServer*(ip: IpAddress, port: Port,
allowedOrigin=none(string),
conf=RestServerConf.default(),
requestErrorHandler: RestRequestErrorHandler = nil):

2
waku/waku_archive/driver.nim
View File

@ -16,7 +16,7 @@ const DefaultPageSize*: uint = 25
type
ArchiveDriverResult*[T] = Result[T, string]
ArchiveDriver* = ref object of RootObj
OnErrHandler* = proc(errMsg: string) {.gcsafe, closure.}
OnErrHandler* = proc(errMsg: string) {.gcsafe, closure, raises: [].}
type ArchiveRow* = (PubsubTopic, WakuMessage, seq[byte], Timestamp)

4
waku/waku_discv5.nim
View File

@ -33,7 +33,7 @@ logScope:
type WakuDiscoveryV5Config* = object
discv5Config*: Option[DiscoveryConfig]
address*: ValidIpAddress
address*: IpAddress
port*: Port
privateKey*: eth_keys.PrivateKey
bootstrapRecords*: seq[waku_enr.Record]
@ -100,7 +100,7 @@ proc new*(
bootstrapRecords = bootstrapRecords,
enrAutoUpdate = conf.autoupdateRecord,
previousRecord = record,
enrIp = none(ValidIpAddress),
enrIp = none(IpAddress),
enrTcpPort = none(Port),
enrUdpPort = none(Port),
)

2
waku/waku_lightpush/common.nim
View File

@ -18,4 +18,4 @@ type PushMessageHandler* = proc(
peer: PeerId,
pubsubTopic: PubsubTopic,
message: WakuMessage
): Future[WakuLightPushResult[void]] {.gcsafe, closure.}
): Future[WakuLightPushResult[void]] {.async.}

6
waku/waku_lightpush/protocol.nim
View File

@ -22,9 +22,9 @@ logScope:
topics = "waku lightpush"
type WakuLightPush* = ref object of LPProtocol
rng*: ref rand.HmacDrbgContext
peerManager*: PeerManager
pushHandler*: PushMessageHandler
rng*: ref rand.HmacDrbgContext
peerManager*: PeerManager
pushHandler*: PushMessageHandler
proc handleRequest*(wl: WakuLightPush, peerId: PeerId, buffer: seq[byte]): Future[PushRPC] {.async.} =
let reqDecodeRes = PushRPC.decode(buffer)

20
waku/waku_rln_relay/group_manager/group_manager_base.nim
View File

@ -44,30 +44,30 @@ type
# This proc is used to initialize the group manager
# Any initialization logic should be implemented here
method init*(g: GroupManager): Future[void] {.base,gcsafe.} =
method init*(g: GroupManager): Future[void] {.base,async.} =
raise newException(CatchableError, "init proc for " & $g.type & " is not implemented yet")
# This proc is used to start the group sync process
# It should be used to sync the group state with the rest of the group members
method startGroupSync*(g: GroupManager): Future[void] {.base,gcsafe.} =
method startGroupSync*(g: GroupManager): Future[void] {.base, async: (raises: [Exception]).} =
raise newException(CatchableError, "startGroupSync proc for " & $g.type & " is not implemented yet")
# This proc is used to register a new identity commitment into the merkle tree
# The user may or may not have the identity secret to this commitment
# It should be used when detecting new members in the group, and syncing the group state
method register*(g: GroupManager, idCommitment: IDCommitment): Future[void] {.base,gcsafe.} =
method register*(g: GroupManager, idCommitment: IDCommitment): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "register proc for " & $g.type & " is not implemented yet")
# This proc is used to register a new identity commitment into the merkle tree
# The user should have the identity secret to this commitment
# It should be used when the user wants to join the group
method register*(g: GroupManager, credentials: IdentityCredential): Future[void] {.base,gcsafe.} =
method register*(g: GroupManager, credentials: IdentityCredential): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "register proc for " & $g.type & " is not implemented yet")
# This proc is used to register a batch of new identity commitments into the merkle tree
# The user may or may not have the identity secret to these commitments
# It should be used when detecting a batch of new members in the group, and syncing the group state
method registerBatch*(g: GroupManager, idCommitments: seq[IDCommitment]): Future[void] {.base,gcsafe.} =
method registerBatch*(g: GroupManager, idCommitments: seq[IDCommitment]): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "registerBatch proc for " & $g.type & " is not implemented yet")
# This proc is used to set a callback that will be called when a new identity commitment is registered
@ -77,19 +77,19 @@ method onRegister*(g: GroupManager, cb: OnRegisterCallback) {.base,gcsafe.} =
# This proc is used to withdraw/remove an identity commitment from the merkle tree
# The user should have the identity secret hash to this commitment, by either deriving it, or owning it
method withdraw*(g: GroupManager, identitySecretHash: IdentitySecretHash): Future[void] {.base,gcsafe.} =
method withdraw*(g: GroupManager, identitySecretHash: IdentitySecretHash): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "withdraw proc for " & $g.type & " is not implemented yet")
# This proc is used to withdraw/remove a batch of identity commitments from the merkle tree
# The user should have the identity secret hash to these commitments, by either deriving them, or owning them
method withdrawBatch*(g: GroupManager, identitySecretHashes: seq[IdentitySecretHash]): Future[void] {.base,gcsafe.} =
method withdrawBatch*(g: GroupManager, identitySecretHashes: seq[IdentitySecretHash]): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "withdrawBatch proc for " & $g.type & " is not implemented yet")
# This proc is used to insert and remove a set of commitments from the merkle tree
method atomicBatch*(g: GroupManager, idCommitments: seq[IDCommitment], toRemoveIndices: seq[MembershipIndex]): Future[void] {.base,gcsafe.} =
method atomicBatch*(g: GroupManager, idCommitments: seq[IDCommitment], toRemoveIndices: seq[MembershipIndex]): Future[void] {.base,async: (raises: [Exception]).} =
raise newException(CatchableError, "atomicBatch proc for " & $g.type & " is not implemented yet")
method stop*(g: GroupManager): Future[void] {.base,gcsafe.} =
method stop*(g: GroupManager): Future[void] {.base,async.} =
raise newException(CatchableError, "stop proc for " & $g.type & " is not implemented yet")
# This proc is used to set a callback that will be called when an identity commitment is withdrawn
@ -163,5 +163,5 @@ method generateProof*(g: GroupManager,
return err("proof generation failed: " & $proofGenRes.error())
return ok(proofGenRes.value())
method isReady*(g: GroupManager): Future[bool] {.base,gcsafe.} =
method isReady*(g: GroupManager): Future[bool] {.base,async.} =
raise newException(CatchableError, "isReady proc for " & $g.type & " is not implemented yet")

44
waku/waku_rln_relay/group_manager/on_chain/group_manager.nim
View File

@ -99,7 +99,8 @@ proc setMetadata*(g: OnchainGroupManager): RlnRelayResult[void] =
method atomicBatch*(g: OnchainGroupManager,
start: MembershipIndex,
idCommitments = newSeq[IDCommitment](),
toRemoveIndices = newSeq[MembershipIndex]()): Future[void] {.async.} =
toRemoveIndices = newSeq[MembershipIndex]()):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
waku_rln_membership_insertion_duration_seconds.nanosecondTime:
@ -123,20 +124,23 @@ method atomicBatch*(g: OnchainGroupManager,
if setMetadataRes.isErr():
error "failed to persist rln metadata", error=setMetadataRes.error
method register*(g: OnchainGroupManager, idCommitment: IDCommitment): Future[void] {.async.} =
method register*(g: OnchainGroupManager, idCommitment: IDCommitment):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
await g.registerBatch(@[idCommitment])
method registerBatch*(g: OnchainGroupManager, idCommitments: seq[IDCommitment]): Future[void] {.async.} =
method registerBatch*(g: OnchainGroupManager, idCommitments: seq[IDCommitment]):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
await g.atomicBatch(g.latestIndex, idCommitments)
g.latestIndex += MembershipIndex(idCommitments.len())
method register*(g: OnchainGroupManager, identityCredentials: IdentityCredential): Future[void] {.async.} =
method register*(g: OnchainGroupManager, identityCredentials: IdentityCredential):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let ethRpc = g.ethRpc.get()
@ -183,12 +187,14 @@ method register*(g: OnchainGroupManager, identityCredentials: IdentityCredential
# don't handle member insertion into the tree here, it will be handled by the event listener
return
method withdraw*(g: OnchainGroupManager, idCommitment: IDCommitment): Future[void] {.async.} =
method withdraw*(g: OnchainGroupManager, idCommitment: IDCommitment):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
# TODO: after slashing is enabled on the contract
method withdrawBatch*(g: OnchainGroupManager, idCommitments: seq[IDCommitment]): Future[void] {.async.} =
method withdrawBatch*(g: OnchainGroupManager, idCommitments: seq[IDCommitment]):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
# TODO: after slashing is enabled on the contract, use atomicBatch internally
@ -217,7 +223,8 @@ proc parseEvent(event: type MemberRegistered,
type BlockTable* = OrderedTable[BlockNumber, seq[(Membership, bool)]]
proc backfillRootQueue*(g: OnchainGroupManager, len: uint): Future[void] {.async.} =
proc backfillRootQueue*(g: OnchainGroupManager, len: uint):
Future[void] {.async: (raises: [Exception]).} =
if len > 0:
# backfill the tree's acceptable roots
for i in 0..len-1:
@ -237,7 +244,7 @@ proc insert(blockTable: var BlockTable, blockNumber: BlockNumber, member: Member
proc getRawEvents(g: OnchainGroupManager,
fromBlock: BlockNumber,
toBlock: BlockNumber): Future[JsonNode] {.async.} =
toBlock: BlockNumber): Future[JsonNode] {.async: (raises: [Exception]).} =
initializedGuard(g)
let ethRpc = g.ethRpc.get()
@ -252,7 +259,7 @@ proc getRawEvents(g: OnchainGroupManager,
proc getBlockTable(g: OnchainGroupManager,
fromBlock: BlockNumber,
toBlock: BlockNumber): Future[BlockTable] {.async.} =
toBlock: BlockNumber): Future[BlockTable] {.async: (raises: [Exception]).} =
initializedGuard(g)
var blockTable = default(BlockTable)
@ -276,7 +283,7 @@ proc getBlockTable(g: OnchainGroupManager,
return blockTable
proc handleEvents(g: OnchainGroupManager,
blockTable: BlockTable): Future[void] {.async.} =
blockTable: BlockTable): Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
for blockNumber, members in blockTable.pairs():
@ -295,7 +302,8 @@ proc handleEvents(g: OnchainGroupManager,
return
proc handleRemovedEvents(g: OnchainGroupManager, blockTable: BlockTable): Future[void] {.async.} =
proc handleRemovedEvents(g: OnchainGroupManager, blockTable: BlockTable):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
# count number of blocks that have been removed
@ -308,7 +316,7 @@ proc handleRemovedEvents(g: OnchainGroupManager, blockTable: BlockTable): Future
proc getAndHandleEvents(g: OnchainGroupManager,
fromBlock: BlockNumber,
toBlock: BlockNumber): Future[void] {.async.} =
toBlock: BlockNumber): Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let blockTable = await g.getBlockTable(fromBlock, toBlock)
@ -339,7 +347,8 @@ proc getNewHeadCallback(g: OnchainGroupManager): BlockHeaderHandler =
proc newHeadErrCallback(error: CatchableError) =
warn "failed to get new head", error=error.msg
proc startListeningToEvents(g: OnchainGroupManager): Future[void] {.async.} =
proc startListeningToEvents(g: OnchainGroupManager):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let ethRpc = g.ethRpc.get()
@ -348,7 +357,8 @@ proc startListeningToEvents(g: OnchainGroupManager): Future[void] {.async.} =
retryWrapper(blockHeaderSub, RetryStrategy.new(), "Failed to subscribe to block headers"):
await ethRpc.subscribeForBlockHeaders(newHeadCallback, newHeadErrCallback)
proc startOnchainSync(g: OnchainGroupManager): Future[void] {.async.} =
proc startOnchainSync(g: OnchainGroupManager):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let ethRpc = g.ethRpc.get()
@ -387,7 +397,8 @@ proc startOnchainSync(g: OnchainGroupManager): Future[void] {.async.} =
except CatchableError:
raise newException(ValueError, "failed to start listening to events: " & getCurrentExceptionMsg())
method startGroupSync*(g: OnchainGroupManager): Future[void] {.async.} =
method startGroupSync*(g: OnchainGroupManager):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
# Get archive history
try:
@ -536,7 +547,8 @@ proc isSyncing*(g: OnchainGroupManager): Future[bool] {.async,gcsafe.} =
await ethRpc.provider.eth_syncing()
return syncing.getBool()
method isReady*(g: OnchainGroupManager): Future[bool] {.async,gcsafe.} =
method isReady*(g: OnchainGroupManager):
Future[bool] {.async.} =
initializedGuard(g)
if g.ethRpc.isNone():

30
waku/waku_rln_relay/group_manager/static/group_manager.nim
View File

@ -15,7 +15,7 @@ template initializedGuard*(g: StaticGroupManager): untyped =
if not g.initialized:
raise newException(ValueError, "StaticGroupManager is not initialized")
method init*(g: StaticGroupManager): Future[void] {.async,gcsafe.} =
method init*(g: StaticGroupManager): Future[void] {.async.} =
let
groupSize = g.groupSize
groupKeys = g.groupKeys
@ -40,20 +40,19 @@ method init*(g: StaticGroupManager): Future[void] {.async,gcsafe.} =
return
method startGroupSync*(g: StaticGroupManager): Future[void] =
method startGroupSync*(g: StaticGroupManager): Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
var retFuture = newFuture[void]("StaticGroupManager.startGroupSync")
# No-op
retFuture.complete()
return retFuture
method register*(g: StaticGroupManager, idCommitment: IDCommitment): Future[void] {.async.} =
method register*(g: StaticGroupManager, idCommitment: IDCommitment):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
await g.registerBatch(@[idCommitment])
method registerBatch*(g: StaticGroupManager, idCommitments: seq[IDCommitment]): Future[void] {.async.} =
method registerBatch*(g: StaticGroupManager, idCommitments: seq[IDCommitment]):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let membersInserted = g.rlnInstance.insertMembers(g.latestIndex + 1, idCommitments)
@ -72,7 +71,8 @@ method registerBatch*(g: StaticGroupManager, idCommitments: seq[IDCommitment]):
return
method withdraw*(g: StaticGroupManager, idSecretHash: IdentitySecretHash): Future[void] {.async.} =
method withdraw*(g: StaticGroupManager, idSecretHash: IdentitySecretHash):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
let groupKeys = g.groupKeys
@ -91,7 +91,8 @@ method withdraw*(g: StaticGroupManager, idSecretHash: IdentitySecretHash): Futur
return
method withdrawBatch*(g: StaticGroupManager, idSecretHashes: seq[IdentitySecretHash]): Future[void] {.async.} =
method withdrawBatch*(g: StaticGroupManager, idSecretHashes: seq[IdentitySecretHash]):
Future[void] {.async: (raises: [Exception]).} =
initializedGuard(g)
# call withdraw on each idSecretHash
@ -104,15 +105,10 @@ method onRegister*(g: StaticGroupManager, cb: OnRegisterCallback) {.gcsafe.} =
method onWithdraw*(g: StaticGroupManager, cb: OnWithdrawCallback) {.gcsafe.} =
g.withdrawCb = some(cb)
method stop*(g: StaticGroupManager): Future[void] =
method stop*(g: StaticGroupManager): Future[void] {.async.} =
initializedGuard(g)
# No-op
var retFut = newFuture[void]("StaticGroupManager.stop")
retFut.complete()
return retFut
method isReady*(g: StaticGroupManager): Future[bool] {.gcsafe.} =
method isReady*(g: StaticGroupManager): Future[bool] {.async.} =
initializedGuard(g)
var retFut = newFuture[bool]("StaticGroupManager.isReady")
retFut.complete(true)
return retFut
return true

10
waku/waku_rln_relay/rln_relay.nim
View File

@ -79,7 +79,7 @@ type WakuRLNRelay* = ref object of RootObj
lastEpoch*: Epoch # the epoch of the last published rln message
groupManager*: GroupManager
method stop*(rlnPeer: WakuRLNRelay) {.async.} =
method stop*(rlnPeer: WakuRLNRelay) {.async: (raises: [Exception]).} =
## stops the rln-relay protocol
## Throws an error if it cannot stop the rln-relay protocol
@ -354,7 +354,7 @@ proc generateRlnValidator*(wakuRlnRelay: WakuRLNRelay,
proc mount(conf: WakuRlnConfig,
registrationHandler = none(RegistrationHandler)
): Future[WakuRlnRelay] {.async.} =
): Future[WakuRlnRelay] {.async: (raises: [Exception]).} =
var
groupManager: GroupManager
# create an RLN instance
@ -393,7 +393,7 @@ proc mount(conf: WakuRlnConfig,
return WakuRLNRelay(groupManager: groupManager)
proc isReady*(rlnPeer: WakuRLNRelay): Future[bool] {.async.} =
proc isReady*(rlnPeer: WakuRLNRelay): Future[bool] {.async: (raises: [Exception]).} =
## returns true if the rln-relay protocol is ready to relay messages
## returns false otherwise
@ -416,6 +416,6 @@ proc new*(T: type WakuRlnRelay,
try:
let rlnRelay = await mount(conf, registrationHandler)
return ok(rlnRelay)
except CatchableError as e:
return err(e.msg)
except:
return err("exception in new WakuRlnRelay: " & getCurrentExceptionMsg())