test: adopt WakuEnvelope in relay handlers across suites

Relay app handlers (WakuRelayHandler) now take a WakuEnvelope; handlers that
used topic/msg get {.used.} aliases. Archive/filter/store-sync test call sites
are unchanged thanks to the compat overloads.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

tests/api/test_api_health.nim

@@ -21,9 +21,7 @@ const TestTimeout = chronos.seconds(10)
 const DefaultShard = PubsubTopic("/waku/2/rs/3/0")
 const TestContentTopic = ContentTopic("/waku/2/default-content/proto")
 
-proc dummyHandler(
-    topic: PubsubTopic, msg: WakuMessage
-): Future[void] {.async, gcsafe.} =
+proc dummyHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
   discard
 
 proc waitForConnectionStatus(

tests/api/test_api_receive.nim

@@ -107,7 +107,7 @@ proc setupNetwork(testTopic: ContentTopic): Future[TestNetwork] {.async.} =
   const numShards: uint16 = 1
   let shard = PubsubTopic("/waku/2/rs/3/0")
 
-  proc dummyHandler(topic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+  proc dummyHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
     discard
 
   # store node: archive + store + relay, subscribed to the shard

tests/api/test_api_send.nim

@@ -209,9 +209,7 @@ suite "Waku API - Send":
 
     # Subscribe all relay nodes to the default shard topic
     const testPubsubTopic = PubsubTopic("/waku/2/rs/3/0")
-    proc dummyHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc dummyHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
       discard
 
     relayNode1.subscribe((kind: PubsubSub, topic: testPubsubTopic), dummyHandler).isOkOr:
@@ -476,9 +474,7 @@ suite "Waku API - Send":
       await fakeLightpushNode.mountLibp2pPing()
       await fakeLightpushNode.start()
     let fakeLightpushNodePeerInfo = fakeLightpushNode.peerInfo.toRemotePeerInfo()
-    proc dummyHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc dummyHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
       discard
 
     fakeLightpushNode.subscribe(

tests/api/test_api_subscription.nim

@@ -108,7 +108,7 @@ proc setupNetwork(
 
   net.publisherPeerInfo = net.publisher.peerInfo.toRemotePeerInfo()
 
-  proc dummyHandler(topic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+  proc dummyHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
     discard
 
   var shards: seq[PubsubTopic]
@@ -617,7 +617,7 @@ suite "Messaging API, SubscriptionManager":
     let numShards: uint16 = 1
     let shards = @[PubsubTopic("/waku/2/rs/3/0")]
 
-    proc dummyHandler(topic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+    proc dummyHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
       discard
 
     var publisher: WakuNode
@@ -726,7 +726,7 @@ suite "Messaging API, SubscriptionManager":
     let numShards: uint16 = 1
     let shards = @[PubsubTopic("/waku/2/rs/3/0")]
 
-    proc dummyHandler(topic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+    proc dummyHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
       discard
 
     var publisher: WakuNode

tests/node/test_wakunode_health_monitor.nim

@@ -171,7 +171,7 @@ suite "Health Monitor - events":
 
     await nodeA.connectToNodes(@[nodeB.switch.peerInfo.toRemotePeerInfo()])
 
-    proc dummyHandler(topic: PubsubTopic, msg: WakuMessage): Future[void] {.async.} =
+    proc dummyHandler(envelope: WakuEnvelope): Future[void] {.async.} =
       discard
 
     nodeA.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), dummyHandler).expect(

tests/node/test_wakunode_legacy_lightpush.nim

@@ -303,9 +303,9 @@ suite "Waku Legacy Lightpush message delivery":
     const CustomPubsubTopic = "/waku/2/rs/0/1"
     let message = fakeWakuMessage()
     var completionFutRelay = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == CustomPubsubTopic
         msg == message

tests/node/test_wakunode_lightpush.nim

@@ -387,12 +387,10 @@ suite "Waku Lightpush message delivery":
     let message = fakeWakuMessage()
 
     var completionFutRelay = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
       check:
-        topic == CustomPubsubTopic
-        msg == message
+        envelope.pubsubTopic == CustomPubsubTopic
+        envelope.msg == message
       completionFutRelay.complete(true)
 
     destNode.subscribe((kind: PubsubSub, topic: CustomPubsubTopic), relayHandler).isOkOr:

tests/node/test_wakunode_relay_rln.nim

@@ -232,9 +232,9 @@ suite "Waku RlnRelay - End to End - Static":
 
       # Register Relay Handler
       var completionFut = newPushHandlerFuture()
-      proc relayHandler(
-          topic: PubsubTopic, msg: WakuMessage
-      ): Future[void] {.async, gcsafe.} =
+      proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let msg {.used.} = envelope.msg
         if topic == pubsubTopic:
           completionFut.complete((topic, msg))
 
@@ -325,9 +325,9 @@ suite "Waku RlnRelay - End to End - Static":
 
       # Register Relay Handler
       var completionFut = newPushHandlerFuture()
-      proc relayHandler(
-          topic: PubsubTopic, msg: WakuMessage
-      ): Future[void] {.async, gcsafe.} =
+      proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let msg {.used.} = envelope.msg
         if topic == pubsubTopic:
           completionFut.complete((topic, msg))
 

tests/test_peer_manager.nim

@@ -668,9 +668,9 @@ procSuite "Peer Manager":
     await allFutures(nodes.mapIt(it.mountRelay()))
     await allFutures(nodes.mapIt(it.start()))
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.millis)
 
     let topic = "/waku/2/rs/0/0"

tests/test_relay_peer_exchange.nim

@@ -91,9 +91,9 @@ procSuite "Relay (GossipSub) Peer Exchange":
     await allFutures([node1.start(), node2.start(), node3.start()])
 
     # The three nodes should be subscribed to the same shard
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node1.subscribe((kind: PubsubSub, topic: $DefaultRelayShard), simpleHandler).isOkOr:

tests/test_waku_metadata.nim

@@ -45,7 +45,7 @@ procSuite "Waku Metadata Protocol":
 
     # Subscribe to topics on node1 - relay will track these and metadata will report them
     let noOpHandler: WakuRelayHandler = proc(
-        pubsubTopic: PubsubTopic, message: WakuMessage
+        envelope: WakuEnvelope
     ): Future[void] {.async.} =
       discard
 

tests/test_wakunode.nim

@@ -58,9 +58,9 @@ suite "WakuNode":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic

tests/waku_relay/test_protocol.nim

@@ -60,10 +60,10 @@ suite "Waku Relay":
     messageSeq = @[]
     handlerFuture = newPushHandlerFuture()
     simpleFutureHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
+        envelope: WakuEnvelope
     ): Future[void] {.async, closure, gcsafe.} =
-      messageSeq.add((topic, msg))
-      handlerFuture.complete((topic, msg))
+      messageSeq.add((envelope.pubsubTopic, envelope.msg))
+      handlerFuture.complete((envelope.pubsubTopic, envelope.msg))
 
     switch = newTestSwitch()
     peerManager = PeerManager.new(switch)
@@ -123,9 +123,9 @@ suite "Waku Relay":
       check await peerManager.connectPeer(otherRemotePeerInfo)
 
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       # When subscribing the second node to the Pubsub Topic
@@ -184,9 +184,9 @@ suite "Waku Relay":
       check await peerManager.connectPeer(otherRemotePeerInfo)
 
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       # When subscribing both nodes to the same Pubsub Topic
@@ -257,9 +257,9 @@ suite "Waku Relay":
 
       # Given the subscription is refreshed
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       node.subscribe(pubsubTopic, otherSimpleFutureHandler)
@@ -303,9 +303,9 @@ suite "Waku Relay":
       check await peerManager.connectPeer(otherRemotePeerInfo)
 
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       otherNode.addValidator(len4Validator)
@@ -393,9 +393,9 @@ suite "Waku Relay":
       check await peerManager.connectPeer(otherRemotePeerInfo)
 
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       node.subscribe(pubsubTopic, simpleFutureHandler)
@@ -477,37 +477,35 @@ suite "Waku Relay":
 
       # Given the first node is subscribed to two pubsub topics
       var handlerFuture2 = newPushHandlerFuture()
-      proc simpleFutureHandler2(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
-        handlerFuture2.complete((topic, message))
+      proc simpleFutureHandler2(envelope: WakuEnvelope) {.async, gcsafe.} =
+        handlerFuture2.complete((envelope.pubsubTopic, envelope.msg))
 
       node.subscribe(pubsubTopic, simpleFutureHandler)
       node.subscribe(pubsubTopicB, simpleFutureHandler2)
 
       # Given the other nodes are subscribed to two pubsub topics
       var otherHandlerFuture1 = newPushHandlerFuture()
-      proc otherSimpleFutureHandler1(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler1(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture1.complete((topic, message))
 
       var otherHandlerFuture2 = newPushHandlerFuture()
-      proc otherSimpleFutureHandler2(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler2(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture2.complete((topic, message))
 
       var anotherHandlerFuture1 = newPushHandlerFuture()
-      proc anotherSimpleFutureHandler1(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc anotherSimpleFutureHandler1(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         anotherHandlerFuture1.complete((topic, message))
 
       var anotherHandlerFuture2 = newPushHandlerFuture()
-      proc anotherSimpleFutureHandler2(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc anotherSimpleFutureHandler2(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         anotherHandlerFuture2.complete((topic, message))
 
       otherNode.subscribe(pubsubTopic, otherSimpleFutureHandler1)
@@ -870,9 +868,9 @@ suite "Waku Relay":
 
       # Given both are subscribed to the same pubsub topic
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       otherNode.subscribe(pubsubTopic, otherSimpleFutureHandler)
@@ -1036,9 +1034,9 @@ suite "Waku Relay":
 
       # Given both are subscribed to the same pubsub topic
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       otherNode.subscribe(pubsubTopic, otherSimpleFutureHandler)
@@ -1169,17 +1167,17 @@ suite "Waku Relay":
       # Create a different handler than the default to include messages in a seq
       var thisHandlerFuture = newPushHandlerFuture()
       var thisMessageSeq: seq[(PubsubTopic, WakuMessage)] = @[]
-      proc thisSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc thisSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         thisMessageSeq.add((topic, message))
         thisHandlerFuture.complete((topic, message))
 
       var otherHandlerFuture = newPushHandlerFuture()
       var otherMessageSeq: seq[(PubsubTopic, WakuMessage)] = @[]
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherMessageSeq.add((topic, message))
         otherHandlerFuture.complete((topic, message))
 
@@ -1252,9 +1250,9 @@ suite "Waku Relay":
 
       # Given both are subscribed to the same pubsub topic
       var otherHandlerFuture = newPushHandlerFuture()
-      proc otherSimpleFutureHandler(
-          topic: PubsubTopic, message: WakuMessage
-      ) {.async, gcsafe.} =
+      proc otherSimpleFutureHandler(envelope: WakuEnvelope) {.async, gcsafe.} =
+        let topic {.used.} = envelope.pubsubTopic
+        let message {.used.} = envelope.msg
         otherHandlerFuture.complete((topic, message))
 
       otherNode.subscribe(pubsubTopic, otherSimpleFutureHandler)

tests/waku_relay/test_wakunode_relay.nim

@@ -87,9 +87,9 @@ suite "WakuNode - Relay":
     )
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -97,9 +97,9 @@ suite "WakuNode - Relay":
         msg.timestamp > 0
       completionFut.complete(true)
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     ## node1 and node2 explicitly subscribe to the same shard as node3
@@ -189,9 +189,9 @@ suite "WakuNode - Relay":
     node2.wakuRelay.addValidator(validator)
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         # check that only messages with contentTopic1 is relayed (but not contentTopic2)
@@ -199,9 +199,9 @@ suite "WakuNode - Relay":
       # relay handler is called
       completionFut.complete(true)
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     ## node1 and node2 explicitly subscribe to the same shard as node3
@@ -295,9 +295,9 @@ suite "WakuNode - Relay":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -347,9 +347,9 @@ suite "WakuNode - Relay":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -408,9 +408,9 @@ suite "WakuNode - Relay":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -467,9 +467,9 @@ suite "WakuNode - Relay":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -527,9 +527,9 @@ suite "WakuNode - Relay":
     await node1.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       check:
         topic == $shard
         msg.contentTopic == contentTopic
@@ -563,9 +563,9 @@ suite "WakuNode - Relay":
     await allFutures(nodes.mapIt(it.start()))
     await allFutures(nodes.mapIt(it.mountRelay()))
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     # subscribe all nodes to a topic
@@ -634,10 +634,9 @@ suite "WakuNode - Relay":
       contentTopicB = ContentTopic("/waku/2/default-content1/proto")
       contentTopicC = ContentTopic("/waku/2/default-content2/proto")
       handler: WakuRelayHandler = proc(
-          pubsubTopic: PubsubTopic, message: WakuMessage
+          envelope: WakuEnvelope
       ): Future[void] {.gcsafe, raises: [Defect].} =
-        discard pubsubTopic
-        discard message
+        discard envelope
     assert shard ==
       node.wakuAutoSharding.get().getShard(contentTopicA).expect("Valid Topic"),
       "topic must use the same shard"

tests/waku_relay/utils.nim

@@ -21,7 +21,7 @@ import
 
 proc noopRawHandler*(): WakuRelayHandler =
   var handler: WakuRelayHandler
-  handler = proc(topic: PubsubTopic, msg: WakuMessage): Future[void] {.async, gcsafe.} =
+  handler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
     discard
   handler
 
@@ -39,11 +39,8 @@ proc subscribeToContentTopicWithHandler*(
     node: WakuNode, contentTopic: string
 ): Future[bool] =
   var completionFut = newFuture[bool]()
-  proc relayHandler(
-      topic: PubsubTopic, msg: WakuMessage
-  ): Future[void] {.async, gcsafe.} =
-    if topic == topic:
-      completionFut.complete(true)
+  proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+    completionFut.complete(true)
 
   (node.subscribe((kind: ContentSub, topic: contentTopic), relayHandler)).isOkOr:
     error "Failed to subscribe to content topic", error
@@ -52,10 +49,8 @@ proc subscribeToContentTopicWithHandler*(
 
 proc subscribeCompletionHandler*(node: WakuNode, pubsubTopic: string): Future[bool] =
   var completionFut = newFuture[bool]()
-  proc relayHandler(
-      topic: PubsubTopic, msg: WakuMessage
-  ): Future[void] {.async, gcsafe.} =
-    if topic == pubsubTopic:
+  proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+    if envelope.pubsubTopic == pubsubTopic:
       completionFut.complete(true)
 
   (node.subscribe((kind: PubsubSub, topic: pubsubTopic), relayHandler)).isOkOr:

tests/waku_rln_relay/test_wakunode_rln_relay.nim

@@ -107,16 +107,16 @@ procSuite "WakuNode - RLN relay":
     await node3.connectToNodes(@[node2.switch.peerInfo.toRemotePeerInfo()])
 
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       info "The received topic:", topic
       if topic == DefaultPubsubTopic:
         completionFut.complete(true)
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node1.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -224,18 +224,18 @@ procSuite "WakuNode - RLN relay":
 
     var rxMessagesTopic1 = 0
     var rxMessagesTopic2 = 0
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       info "relayHandler. The received topic:", topic
       if topic == $shards[0]:
         rxMessagesTopic1 = rxMessagesTopic1 + 1
       elif topic == $shards[1]:
         rxMessagesTopic2 = rxMessagesTopic2 + 1
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node1.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -366,16 +366,16 @@ procSuite "WakuNode - RLN relay":
 
     # define a custom relay handler
     var completionFut = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       info "The received topic:", topic
       if topic == DefaultPubsubTopic:
         completionFut.complete(true)
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node1.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -526,9 +526,9 @@ procSuite "WakuNode - RLN relay":
     var completionFut2 = newFuture[bool]()
     var completionFut3 = newFuture[bool]()
     var completionFut4 = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       info "The received topic:", topic
       if topic == DefaultPubsubTopic:
         if msg == wm1:
@@ -540,9 +540,9 @@ procSuite "WakuNode - RLN relay":
         if msg.payload == wm4.payload:
           completionFut4.complete(true)
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node1.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -649,9 +649,9 @@ procSuite "WakuNode - RLN relay":
       completionFut4 = newFuture[bool]()
       completionFut5 = newFuture[bool]()
       completionFut6 = newFuture[bool]()
-    proc relayHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       info "The received topic:", topic
       if topic == DefaultPubsubTopic:
         if msg == wm1:

tests/waku_rln_relay/utils_offchain.nim

@@ -34,9 +34,9 @@ proc setupRelayWithStaticRln*(
 
 proc subscribeCompletionHandler*(node: WakuNode, pubsubTopic: string): Future[bool] =
   var completionFut = newFuture[bool]()
-  proc relayHandler(
-      topic: PubsubTopic, msg: WakuMessage
-  ): Future[void] {.async, gcsafe.} =
+  proc relayHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+    let topic {.used.} = envelope.pubsubTopic
+    let msg {.used.} = envelope.msg
     if topic == pubsubTopic:
       completionFut.complete(true)
 

tests/wakunode2/test_validators.nim

@@ -61,7 +61,7 @@ suite "WakuNode2 - Validators":
     await sleepAsync(500.millis)
 
     var msgReceived = 0
-    proc handler(pubsubTopic: PubsubTopic, data: WakuMessage) {.async, gcsafe.} =
+    proc handler(envelope: WakuEnvelope) {.async, gcsafe.} =
       msgReceived += 1
 
     # Subscribe all nodes to the same topic/handler
@@ -148,7 +148,7 @@ suite "WakuNode2 - Validators":
         require connOk
 
     var msgReceived = 0
-    proc handler(pubsubTopic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+    proc handler(envelope: WakuEnvelope) {.async, gcsafe.} =
       msgReceived += 1
 
     # Connection triggers different actions, wait for them
@@ -279,7 +279,7 @@ suite "WakuNode2 - Validators":
     await allFutures(nodes.mapIt(it.mountRelay()))
 
     var msgReceived = 0
-    proc handler(pubsubTopic: PubsubTopic, msg: WakuMessage) {.async, gcsafe.} =
+    proc handler(envelope: WakuEnvelope) {.async, gcsafe.} =
       msgReceived += 1
 
     # Subscribe all nodes to the same topic/handler

tests/wakunode_rest/test_rest_admin.nim

@@ -60,9 +60,9 @@ suite "Waku v2 Rest API - Admin":
     )
 
     # The three nodes should be subscribed to the same shard
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     let shard = RelayShard(clusterId: clusterId, shardId: 5)

tests/wakunode_rest/test_rest_filter.nim

@@ -278,9 +278,9 @@ suite "Waku v2 Rest API - Filter V2":
       restFilterTest = await RestFilterTest.init()
       subPeerId = restFilterTest.subscriberNode.peerInfo.toRemotePeerInfo().peerId
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restFilterTest.messageCache.pubsubSubscribe(DefaultPubsubTopic)
@@ -333,9 +333,9 @@ suite "Waku v2 Rest API - Filter V2":
     # setup filter service and client node
     let restFilterTest = await RestFilterTest.init()
     let subPeerId = restFilterTest.subscriberNode.peerInfo.toRemotePeerInfo().peerId
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restFilterTest.serviceNode.subscribe(
@@ -412,9 +412,9 @@ suite "Waku v2 Rest API - Filter V2":
     # setup filter service and client node
     let restFilterTest = await RestFilterTest.init()
     let subPeerId = restFilterTest.subscriberNode.peerInfo.toRemotePeerInfo().peerId
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restFilterTest.serviceNode.subscribe(

tests/wakunode_rest/test_rest_lightpush.nim

@@ -129,9 +129,9 @@ suite "Waku v2 Rest API - lightpush":
     # Given
     let restLightPushTest = await RestLightPushTest.init()
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.consumerNode.subscribe(
@@ -168,9 +168,9 @@ suite "Waku v2 Rest API - lightpush":
   asyncTest "Push message bad-request":
     # Given
     let restLightPushTest = await RestLightPushTest.init()
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.serviceNode.subscribe(
@@ -230,9 +230,9 @@ suite "Waku v2 Rest API - lightpush":
     let budgetCap = 3
     let tokenPeriod = 500.millis
     let restLightPushTest = await RestLightPushTest.init((budgetCap, tokenPeriod))
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.consumerNode.subscribe(

tests/wakunode_rest/test_rest_lightpush_legacy.nim

@@ -123,9 +123,9 @@ suite "Waku v2 Rest API - lightpush":
   asyncTest "Push message request":
     # Given
     let restLightPushTest = await RestLightPushTest.init()
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.consumerNode.subscribe(
@@ -162,9 +162,9 @@ suite "Waku v2 Rest API - lightpush":
   asyncTest "Push message bad-request":
     # Given
     let restLightPushTest = await RestLightPushTest.init()
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.serviceNode.subscribe(
@@ -227,9 +227,9 @@ suite "Waku v2 Rest API - lightpush":
     let budgetCap = 3
     let tokenPeriod = 500.millis
     let restLightPushTest = await RestLightPushTest.init((budgetCap, tokenPeriod))
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     restLightPushTest.consumerNode.subscribe(

tests/wakunode_rest/test_rest_relay.nim

@@ -126,9 +126,9 @@ suite "Waku v2 Rest API - Relay":
     (await node.mountRelay()).isOkOr:
       assert false, "Failed to mount relay"
 
-    proc simpleHandler(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    proc simpleHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     for shard in @[$shard0, $shard1, $shard2, $shard3, $shard4]:
@@ -292,9 +292,9 @@ suite "Waku v2 Rest API - Relay":
 
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -512,9 +512,7 @@ suite "Waku v2 Rest API - Relay":
       await meshNode.setRlnValidator(wakuRlnConfig)
       await meshNode.start()
       const testPubsubTopic = PubsubTopic("/waku/2/rs/1/0")
-      proc dummyHandler(
-          topic: PubsubTopic, msg: WakuMessage
-      ): Future[void] {.async, gcsafe.} =
+      proc dummyHandler(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
         discard
 
       meshNode.subscribe((kind: ContentSub, topic: DefaultContentTopic), dummyHandler).isOkOr:
@@ -562,9 +560,9 @@ suite "Waku v2 Rest API - Relay":
 
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: ContentSub, topic: DefaultContentTopic), simpleHandler).isOkOr:
@@ -691,9 +689,9 @@ suite "Waku v2 Rest API - Relay":
 
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -763,9 +761,9 @@ suite "Waku v2 Rest API - Relay":
 
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -839,9 +837,9 @@ suite "Waku v2 Rest API - Relay":
     restServer.start()
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: PubsubSub, topic: DefaultPubsubTopic), simpleHandler).isOkOr:
@@ -897,9 +895,9 @@ suite "Waku v2 Rest API - Relay":
       assert false, "Failed to mount relay on mesh node"
     require meshNode.mountAutoSharding(1, 8).isOk
     await meshNode.start()
-    let meshHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let meshHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       discard
     meshNode.subscribe((kind: ContentSub, topic: DefaultContentTopic), meshHandler).isOkOr:
       assert false, "Failed to subscribe mesh node"
@@ -946,9 +944,9 @@ suite "Waku v2 Rest API - Relay":
     restServer.start()
     let client = newRestHttpClient(initTAddress(restAddress, restPort))
 
-    let simpleHandler = proc(
-        topic: PubsubTopic, msg: WakuMessage
-    ): Future[void] {.async, gcsafe.} =
+    let simpleHandler = proc(envelope: WakuEnvelope): Future[void] {.async, gcsafe.} =
+      let topic {.used.} = envelope.pubsubTopic
+      let msg {.used.} = envelope.msg
       await sleepAsync(0.milliseconds)
 
     node.subscribe((kind: ContentSub, topic: DefaultContentTopic), simpleHandler).isOkOr: