mirror of https://github.com/waku-org/nwaku.git
561 lines
19 KiB
Nim
561 lines
19 KiB
Nim
#
|
|
# Waku
|
|
# (c) Copyright 2019
|
|
# Status Research & Development GmbH
|
|
#
|
|
# Licensed under either of
|
|
# Apache License, version 2.0, (LICENSE-APACHEv2)
|
|
# MIT license (LICENSE-MIT)
|
|
{.used.}
|
|
|
|
import
|
|
std/[sequtils, tables, unittest],
|
|
chronos, eth/[keys, p2p], eth/p2p/peer_pool,
|
|
../../waku/v1/protocol/waku_protocol,
|
|
../test_helpers
|
|
|
|
const
|
|
safeTTL = 5'u32
|
|
waitInterval = messageInterval + 150.milliseconds
|
|
conditionTimeoutMs = 3000.milliseconds
|
|
|
|
proc resetMessageQueues(nodes: varargs[EthereumNode]) =
|
|
for node in nodes:
|
|
node.resetMessageQueue()
|
|
|
|
# check on a condition until true or return a future containing false
|
|
# if timeout expires first
|
|
proc eventually(timeout: Duration, condition: proc(): bool {.gcsafe.}):
|
|
Future[bool] =
|
|
let wrappedCondition = proc(): Future[bool] {.async.} =
|
|
let f = newFuture[bool]()
|
|
while not condition():
|
|
await sleepAsync(100.milliseconds)
|
|
f.complete(true)
|
|
return await f
|
|
return withTimeout(wrappedCondition(), timeout)
|
|
|
|
procSuite "Waku connections":
|
|
let rng = keys.newRng()
|
|
asyncTest "Waku connections":
|
|
var
|
|
n1 = setupTestNode(rng, Waku)
|
|
n2 = setupTestNode(rng, Waku)
|
|
n3 = setupTestNode(rng, Waku)
|
|
n4 = setupTestNode(rng, Waku)
|
|
|
|
var topics: seq[Topic]
|
|
n1.protocolState(Waku).config.topics = some(topics)
|
|
n2.protocolState(Waku).config.topics = some(topics)
|
|
n3.protocolState(Waku).config.topics = none(seq[Topic])
|
|
n4.protocolState(Waku).config.topics = none(seq[Topic])
|
|
|
|
n1.startListening()
|
|
n3.startListening()
|
|
|
|
let
|
|
p1 = await n2.rlpxConnect(newNode(n1.toENode()))
|
|
p2 = await n2.rlpxConnect(newNode(n3.toENode()))
|
|
p3 = await n4.rlpxConnect(newNode(n3.toENode()))
|
|
check:
|
|
p1.isNil
|
|
p2.isNil == false
|
|
p3.isNil == false
|
|
|
|
asyncTest "Filters with encryption and signing":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let encryptKeyPair = KeyPair.random(rng[])
|
|
let signKeyPair = KeyPair.random(rng[])
|
|
var symKey: SymKey
|
|
let topic = [byte 0x12, 0, 0, 0]
|
|
var filters: seq[string] = @[]
|
|
var payloads = [repeat(byte 1, 10), repeat(byte 2, 10),
|
|
repeat(byte 3, 10), repeat(byte 4, 10)]
|
|
var futures = [newFuture[int](), newFuture[int](),
|
|
newFuture[int](), newFuture[int]()]
|
|
|
|
proc handler1(msg: ReceivedMessage) =
|
|
var count {.global.}: int
|
|
check msg.decoded.payload == payloads[0] or
|
|
msg.decoded.payload == payloads[1]
|
|
count += 1
|
|
if count == 2: futures[0].complete(1)
|
|
proc handler2(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payloads[1]
|
|
futures[1].complete(1)
|
|
proc handler3(msg: ReceivedMessage) =
|
|
var count {.global.}: int
|
|
check msg.decoded.payload == payloads[2] or
|
|
msg.decoded.payload == payloads[3]
|
|
count += 1
|
|
if count == 2: futures[2].complete(1)
|
|
proc handler4(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payloads[3]
|
|
futures[3].complete(1)
|
|
|
|
# Filters
|
|
# filter for encrypted asym
|
|
filters.add(node1.subscribeFilter(initFilter(
|
|
privateKey = some(encryptKeyPair.seckey), topics = @[topic]), handler1))
|
|
# filter for encrypted asym + signed
|
|
filters.add(node1.subscribeFilter(initFilter(some(signKeyPair.pubkey),
|
|
privateKey = some(encryptKeyPair.seckey), topics = @[topic]), handler2))
|
|
# filter for encrypted sym
|
|
filters.add(node1.subscribeFilter(initFilter(symKey = some(symKey),
|
|
topics = @[topic]), handler3))
|
|
# filter for encrypted sym + signed
|
|
filters.add(node1.subscribeFilter(initFilter(some(signKeyPair.pubkey),
|
|
symKey = some(symKey), topics = @[topic]), handler4))
|
|
# Messages
|
|
check:
|
|
# encrypted asym
|
|
node2.postMessage(some(encryptKeyPair.pubkey), ttl = safeTTL,
|
|
topic = topic, payload = payloads[0]) == true
|
|
# encrypted asym + signed
|
|
node2.postMessage(some(encryptKeyPair.pubkey),
|
|
src = some(signKeyPair.seckey), ttl = safeTTL,
|
|
topic = topic, payload = payloads[1]) == true
|
|
# encrypted sym
|
|
node2.postMessage(symKey = some(symKey), ttl = safeTTL, topic = topic,
|
|
payload = payloads[2]) == true
|
|
# encrypted sym + signed
|
|
node2.postMessage(symKey = some(symKey),
|
|
src = some(signKeyPair.seckey),
|
|
ttl = safeTTL, topic = topic,
|
|
payload = payloads[3]) == true
|
|
|
|
node2.protocolState(Waku).queue.items.len == 4
|
|
|
|
check:
|
|
await allFutures(futures).withTimeout(waitInterval)
|
|
node1.protocolState(Waku).queue.items.len == 4
|
|
|
|
for filter in filters:
|
|
check node1.unsubscribeFilter(filter) == true
|
|
|
|
asyncTest "Filters with topics":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic1 = [byte 0x12, 0, 0, 0]
|
|
let topic2 = [byte 0x34, 0, 0, 0]
|
|
var payloads = [repeat(byte 0, 10), repeat(byte 1, 10)]
|
|
var futures = [newFuture[int](), newFuture[int]()]
|
|
proc handler1(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payloads[0]
|
|
futures[0].complete(1)
|
|
proc handler2(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payloads[1]
|
|
futures[1].complete(1)
|
|
|
|
var filter1 = node1.subscribeFilter(initFilter(topics = @[topic1]), handler1)
|
|
var filter2 = node1.subscribeFilter(initFilter(topics = @[topic2]), handler2)
|
|
|
|
check:
|
|
node2.postMessage(ttl = safeTTL + 1, topic = topic1,
|
|
payload = payloads[0]) == true
|
|
node2.postMessage(ttl = safeTTL, topic = topic2,
|
|
payload = payloads[1]) == true
|
|
node2.protocolState(Waku).queue.items.len == 2
|
|
|
|
await allFutures(futures).withTimeout(waitInterval)
|
|
node1.protocolState(Waku).queue.items.len == 2
|
|
|
|
node1.unsubscribeFilter(filter1) == true
|
|
node1.unsubscribeFilter(filter2) == true
|
|
|
|
asyncTest "Filters with PoW":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0x12, 0, 0, 0]
|
|
var payload = repeat(byte 0, 10)
|
|
var futures = [newFuture[int](), newFuture[int]()]
|
|
proc handler1(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payload
|
|
futures[0].complete(1)
|
|
proc handler2(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payload
|
|
futures[1].complete(1)
|
|
|
|
var filter1 = node1.subscribeFilter(
|
|
initFilter(topics = @[topic], powReq = 0), handler1)
|
|
var filter2 = node1.subscribeFilter(
|
|
initFilter(topics = @[topic], powReq = 1_000_000), handler2)
|
|
|
|
check:
|
|
node2.postMessage(ttl = safeTTL, topic = topic, payload = payload) == true
|
|
|
|
(await futures[0].withTimeout(waitInterval)) == true
|
|
(await futures[1].withTimeout(waitInterval)) == false
|
|
node1.protocolState(Waku).queue.items.len == 1
|
|
|
|
node1.unsubscribeFilter(filter1) == true
|
|
node1.unsubscribeFilter(filter2) == true
|
|
|
|
asyncTest "Filters with queues":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
let payload = repeat(byte 0, 10)
|
|
|
|
var filter = node1.subscribeFilter(initFilter(topics = @[topic]))
|
|
for i in countdown(10, 1):
|
|
check node2.postMessage(ttl = safeTTL, topic = topic,
|
|
payload = payload) == true
|
|
|
|
await sleepAsync(waitInterval)
|
|
check:
|
|
node1.getFilterMessages(filter).len() == 10
|
|
node1.getFilterMessages(filter).len() == 0
|
|
node1.unsubscribeFilter(filter) == true
|
|
|
|
asyncTest "Local filter notify":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
|
|
var filter = node1.subscribeFilter(initFilter(topics = @[topic]))
|
|
check:
|
|
node1.postMessage(ttl = safeTTL, topic = topic,
|
|
payload = repeat(byte 4, 10)) == true
|
|
node1.getFilterMessages(filter).len() == 1
|
|
node1.unsubscribeFilter(filter) == true
|
|
|
|
asyncTest "Bloomfilter blocking":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let sendTopic1 = [byte 0x12, 0, 0, 0]
|
|
let sendTopic2 = [byte 0x34, 0, 0, 0]
|
|
let filterTopics = @[[byte 0x34, 0, 0, 0],[byte 0x56, 0, 0, 0]]
|
|
let payload = repeat(byte 0, 10)
|
|
var f: Future[int] = newFuture[int]()
|
|
proc handler(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == payload
|
|
f.complete(1)
|
|
var filter = node1.subscribeFilter(
|
|
initFilter(topics = filterTopics), handler)
|
|
await node1.setBloomFilter(node1.filtersToBloom())
|
|
|
|
check:
|
|
node2.postMessage(ttl = safeTTL, topic = sendTopic1,
|
|
payload = payload) == true
|
|
node2.protocolState(Waku).queue.items.len == 1
|
|
|
|
(await f.withTimeout(waitInterval)) == false
|
|
node1.protocolState(Waku).queue.items.len == 0
|
|
|
|
resetMessageQueues(node1, node2)
|
|
|
|
f = newFuture[int]()
|
|
|
|
check:
|
|
node2.postMessage(ttl = safeTTL, topic = sendTopic2,
|
|
payload = payload) == true
|
|
node2.protocolState(Waku).queue.items.len == 1
|
|
|
|
await f.withTimeout(waitInterval)
|
|
f.read() == 1
|
|
node1.protocolState(Waku).queue.items.len == 1
|
|
|
|
node1.unsubscribeFilter(filter) == true
|
|
|
|
await node1.setBloomFilter(fullBloom())
|
|
|
|
asyncTest "PoW blocking":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
let payload = repeat(byte 0, 10)
|
|
|
|
await node1.setPowRequirement(1_000_000)
|
|
check:
|
|
node2.postMessage(ttl = safeTTL, topic = topic, payload = payload) == true
|
|
node2.protocolState(Waku).queue.items.len == 1
|
|
await sleepAsync(waitInterval)
|
|
check:
|
|
node1.protocolState(Waku).queue.items.len == 0
|
|
|
|
resetMessageQueues(node1, node2)
|
|
|
|
await node1.setPowRequirement(0.0)
|
|
check:
|
|
node2.postMessage(ttl = safeTTL, topic = topic, payload = payload) == true
|
|
node2.protocolState(Waku).queue.items.len == 1
|
|
await sleepAsync(waitInterval)
|
|
check:
|
|
node1.protocolState(Waku).queue.items.len == 1
|
|
|
|
asyncTest "Queue pruning":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
let payload = repeat(byte 0, 10)
|
|
# We need a minimum TTL of 2 as when set to 1 there is a small chance that
|
|
# it is already expired after messageInterval due to rounding down of float
|
|
# to uint32 in postMessage()
|
|
let lowerTTL = 2'u32 # Lower TTL as we need to wait for messages to expire
|
|
for i in countdown(10, 1):
|
|
check node2.postMessage(ttl = lowerTTL, topic = topic, payload = payload)
|
|
check node2.protocolState(Waku).queue.items.len == 10
|
|
|
|
await sleepAsync(waitInterval)
|
|
check node1.protocolState(Waku).queue.items.len == 10
|
|
|
|
await sleepAsync(milliseconds((lowerTTL+1)*1000))
|
|
check node1.protocolState(Waku).queue.items.len == 0
|
|
check node2.protocolState(Waku).queue.items.len == 0
|
|
|
|
asyncTest "P2P post":
|
|
var node1 = setupTestNode(rng, Waku)
|
|
var node2 = setupTestNode(rng, Waku)
|
|
node2.startListening()
|
|
waitFor node1.peerPool.connectToNode(newNode(node2.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
var f: Future[int] = newFuture[int]()
|
|
proc handler(msg: ReceivedMessage) =
|
|
check msg.decoded.payload == repeat(byte 4, 10)
|
|
f.complete(1)
|
|
|
|
var filter = node1.subscribeFilter(initFilter(topics = @[topic],
|
|
allowP2P = true), handler)
|
|
# Need to be sure that node1 is added in the peerpool of node2 as
|
|
# postMessage with target will iterate over the peers
|
|
require await eventually(conditionTimeoutMs,
|
|
proc(): bool = node2.peerPool.len == 1)
|
|
check:
|
|
node1.setPeerTrusted(toNodeId(node2.keys.pubkey)) == true
|
|
node2.postMessage(ttl = 10, topic = topic,
|
|
payload = repeat(byte 4, 10),
|
|
targetPeer = some(toNodeId(node1.keys.pubkey))) == true
|
|
|
|
await f.withTimeout(waitInterval)
|
|
f.read() == 1
|
|
node1.protocolState(Waku).queue.items.len == 0
|
|
node2.protocolState(Waku).queue.items.len == 0
|
|
|
|
node1.unsubscribeFilter(filter) == true
|
|
|
|
asyncTest "Light node posting":
|
|
var ln = setupTestNode(rng, Waku)
|
|
await ln.setLightNode(true)
|
|
var fn = setupTestNode(rng, Waku)
|
|
fn.startListening()
|
|
await ln.peerPool.connectToNode(newNode(fn.toENode()))
|
|
|
|
let topic = [byte 0, 0, 0, 0]
|
|
|
|
check:
|
|
ln.peerPool.connectedNodes.len() == 1
|
|
# normal post
|
|
ln.postMessage(ttl = safeTTL, topic = topic,
|
|
payload = repeat(byte 0, 10)) == true
|
|
ln.protocolState(Waku).queue.items.len == 1
|
|
# TODO: add test on message relaying
|
|
|
|
asyncTest "Connect two light nodes":
|
|
var ln1 = setupTestNode(rng, Waku)
|
|
var ln2 = setupTestNode(rng, Waku)
|
|
|
|
await ln1.setLightNode(true)
|
|
await ln2.setLightNode(true)
|
|
|
|
ln2.startListening()
|
|
let peer = await ln1.rlpxConnect(newNode(ln2.toENode()))
|
|
check peer.isNil == true
|
|
|
|
asyncTest "Waku set-topic-interest":
|
|
var
|
|
wakuTopicNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
|
|
let
|
|
topic1 = [byte 0xDA, 0xDA, 0xDA, 0xAA]
|
|
topic2 = [byte 0xD0, 0xD0, 0xD0, 0x00]
|
|
wrongTopic = [byte 0x4B, 0x1D, 0x4B, 0x1D]
|
|
|
|
# Set one topic so we are not considered a full node
|
|
wakuTopicNode.protocolState(Waku).config.topics = some(@[topic1])
|
|
|
|
wakuNode.startListening()
|
|
await wakuTopicNode.peerPool.connectToNode(newNode(wakuNode.toENode()))
|
|
|
|
# Update topic interest
|
|
check:
|
|
await setTopicInterest(wakuTopicNode, @[topic1, topic2])
|
|
|
|
let payload = repeat(byte 0, 10)
|
|
check:
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic1, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic2, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = wrongTopic, payload = payload)
|
|
wakuNode.protocolState(Waku).queue.items.len == 3
|
|
await sleepAsync(waitInterval)
|
|
check:
|
|
wakuTopicNode.protocolState(Waku).queue.items.len == 2
|
|
|
|
asyncTest "Waku set-minimum-pow":
|
|
var
|
|
wakuPowNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
|
|
wakuNode.startListening()
|
|
await wakuPowNode.peerPool.connectToNode(newNode(wakuNode.toENode()))
|
|
|
|
# Update minimum pow
|
|
await setPowRequirement(wakuPowNode, 1.0)
|
|
await sleepAsync(waitInterval)
|
|
|
|
check:
|
|
wakuNode.peerPool.len == 1
|
|
|
|
# check powRequirement is updated
|
|
for peer in wakuNode.peerPool.peers:
|
|
check:
|
|
peer.state(Waku).powRequirement == 1.0
|
|
|
|
asyncTest "Waku set-light-node":
|
|
var
|
|
wakuLightNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
|
|
wakuNode.startListening()
|
|
await wakuLightNode.peerPool.connectToNode(newNode(wakuNode.toENode()))
|
|
|
|
# Update minimum pow
|
|
await setLightNode(wakuLightNode, true)
|
|
await sleepAsync(waitInterval)
|
|
|
|
check:
|
|
wakuNode.peerPool.len == 1
|
|
|
|
# check lightNode is updated
|
|
for peer in wakuNode.peerPool.peers:
|
|
check:
|
|
peer.state(Waku).isLightNode
|
|
|
|
asyncTest "Waku set-bloom-filter":
|
|
var
|
|
wakuBloomNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
bloom = fullBloom()
|
|
topics = @[[byte 0xDA, 0xDA, 0xDA, 0xAA]]
|
|
|
|
# Set topic interest
|
|
discard await wakuBloomNode.setTopicInterest(topics)
|
|
|
|
wakuBloomNode.startListening()
|
|
await wakuNode.peerPool.connectToNode(newNode(wakuBloomNode.toENode()))
|
|
|
|
# Sanity check
|
|
check:
|
|
wakuNode.peerPool.len == 1
|
|
|
|
# check bloom filter is updated
|
|
for peer in wakuNode.peerPool.peers:
|
|
check:
|
|
peer.state(Waku).bloom == bloom
|
|
peer.state(Waku).topics == some(topics)
|
|
|
|
let hasBloomNodeConnectedCondition = proc(): bool =
|
|
wakuBloomNode.peerPool.len == 1
|
|
# wait for the peer to be connected on the other side
|
|
let hasBloomNodeConnected =
|
|
await eventually(conditionTimeoutMs, hasBloomNodeConnectedCondition)
|
|
# check bloom filter is updated
|
|
check:
|
|
hasBloomNodeConnected
|
|
|
|
# disable one bit in the bloom filter
|
|
bloom[0] = 0x0
|
|
|
|
# and set it
|
|
await setBloomFilter(wakuBloomNode, bloom)
|
|
|
|
let bloomFilterUpdatedCondition = proc(): bool =
|
|
for peer in wakuNode.peerPool.peers:
|
|
return peer.state(Waku).bloom == bloom and
|
|
peer.state(Waku).topics == none(seq[Topic])
|
|
|
|
let bloomFilterUpdated =
|
|
await eventually(conditionTimeoutMs, bloomFilterUpdatedCondition)
|
|
# check bloom filter is updated
|
|
check:
|
|
bloomFilterUpdated
|
|
|
|
asyncTest "Waku topic-interest":
|
|
var
|
|
wakuTopicNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
|
|
let
|
|
topic1 = [byte 0xDA, 0xDA, 0xDA, 0xAA]
|
|
topic2 = [byte 0xD0, 0xD0, 0xD0, 0x00]
|
|
wrongTopic = [byte 0x4B, 0x1D, 0x4B, 0x1D]
|
|
|
|
wakuTopicNode.protocolState(Waku).config.topics = some(@[topic1, topic2])
|
|
|
|
wakuNode.startListening()
|
|
await wakuTopicNode.peerPool.connectToNode(newNode(wakuNode.toENode()))
|
|
|
|
let payload = repeat(byte 0, 10)
|
|
check:
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic1, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic2, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = wrongTopic, payload = payload)
|
|
wakuNode.protocolState(Waku).queue.items.len == 3
|
|
|
|
await eventually(conditionTimeoutMs,
|
|
proc (): bool = wakuTopicNode.protocolState(Waku).queue.items.len == 2)
|
|
|
|
asyncTest "Waku topic-interest versus bloom filter":
|
|
var
|
|
wakuTopicNode = setupTestNode(rng, Waku)
|
|
wakuNode = setupTestNode(rng, Waku)
|
|
|
|
let
|
|
topic1 = [byte 0xDA, 0xDA, 0xDA, 0xAA]
|
|
topic2 = [byte 0xD0, 0xD0, 0xD0, 0x00]
|
|
bloomTopic = [byte 0x4B, 0x1D, 0x4B, 0x1D]
|
|
|
|
# It was checked that the topics don't trigger false positives on the bloom.
|
|
wakuTopicNode.protocolState(Waku).config.topics = some(@[topic1, topic2])
|
|
wakuTopicNode.protocolState(Waku).config.bloom = some(toBloom([bloomTopic]))
|
|
|
|
wakuNode.startListening()
|
|
await wakuTopicNode.peerPool.connectToNode(newNode(wakuNode.toENode()))
|
|
|
|
let payload = repeat(byte 0, 10)
|
|
check:
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic1, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = topic2, payload = payload)
|
|
wakuNode.postMessage(ttl = safeTTL, topic = bloomTopic, payload = payload)
|
|
wakuNode.protocolState(Waku).queue.items.len == 3
|
|
await sleepAsync(waitInterval)
|
|
check:
|
|
wakuTopicNode.protocolState(Waku).queue.items.len == 2
|