From c3dea59e8fc56fd610c6169e9e04c3c470ff2420 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=81lex=20Cabeza=20Romero?= <alex93cabeza@gmail.com>
Date: Tue, 6 Feb 2024 17:37:42 +0100
Subject: [PATCH] test(lightpush): Lightpush functional tests (#2269)

* Add ligthpush payload tests.
* Add end to end lightpush tests.
* updating vendor/nim-unittest2 to protect against core dump issue
* Enable "Valid Payload Sizes" test again
---------
Co-authored-by: Ivan FB <128452529+Ivansete-status@users.noreply.github.com>
---
 tests/all_tests_waku.nim                 |  23 +-
 tests/node/test_all.nim                  |   4 +
 tests/node/test_wakunode_filter.nim      | 108 +--
 tests/node/test_wakunode_lightpush.nim   |  93 +++
 tests/node/test_wakunode_store.nim       | 836 ++++++++++++-----------
 tests/resources/content_topics.nim       |   8 +
 tests/resources/pubsub_topics.nim        |  14 +
 tests/test_waku_lightpush.nim            | 154 -----
 tests/testlib/assertions.nim             |   4 +
 tests/testlib/futures.nim                |  20 +
 tests/waku_archive/archive_utils.nim     |  34 +-
 tests/waku_lightpush/lightpush_utils.nim |  33 +
 tests/waku_lightpush/test_all.nim        |   2 +
 tests/waku_lightpush/test_client.nim     | 362 ++++++++++
 tests/waku_store/test_all.nim            |   1 +
 tests/waku_store/test_client.nim         |   7 +-
 vendor/nim-unittest2                     |   2 +-
 waku/waku_lightpush/client.nim           |   7 +-
 18 files changed, 1077 insertions(+), 635 deletions(-)
 create mode 100644 tests/node/test_all.nim
 create mode 100644 tests/node/test_wakunode_lightpush.nim
 create mode 100644 tests/resources/content_topics.nim
 create mode 100644 tests/resources/pubsub_topics.nim
 delete mode 100644 tests/test_waku_lightpush.nim
 create mode 100644 tests/testlib/assertions.nim
 create mode 100644 tests/waku_lightpush/lightpush_utils.nim
 create mode 100644 tests/waku_lightpush/test_all.nim
 create mode 100644 tests/waku_lightpush/test_client.nim

diff --git a/tests/all_tests_waku.nim b/tests/all_tests_waku.nim
index 35e9f41a6..303021404 100644
--- a/tests/all_tests_waku.nim
+++ b/tests/all_tests_waku.nim
@@ -8,7 +8,6 @@ import
   ./waku_core/test_peers,
   ./waku_core/test_published_address
 
-
 # Waku archive test suite
 import
   ./waku_archive/test_driver_queue_index,
@@ -22,15 +21,15 @@ import
 
 const os* {.strdefine.} = ""
 when os == "Linux" and
-  # GitHub only supports container actions on Linux
-  # and we need to start a postgress database in a docker container
-  defined(postgres):
+# GitHub only supports container actions on Linux
+# and we need to start a postgress database in a docker container
+defined(postgres):
   import
-    ./waku_archive/test_driver_postgres_query,
-    ./waku_archive/test_driver_postgres
+    ./waku_archive/test_driver_postgres_query, ./waku_archive/test_driver_postgres
 
 # Waku store test suite
 import
+  ./waku_store/test_client,
   ./waku_store/test_rpc_codec,
   ./waku_store/test_waku_store,
   ./waku_store/test_wakunode_store
@@ -39,17 +38,11 @@ when defined(waku_exp_store_resume):
   # TODO: Review store resume test cases (#1282)
   import ./waku_store/test_resume
 
-
-import 
-  ./waku_relay/test_all,
-  ./waku_filter_v2/test_all
-
+import ./waku_relay/test_all, ./waku_filter_v2/test_all, ./waku_lightpush/test_all
 
 import
   # Waku v2 tests
   ./test_wakunode,
-  # Waku LightPush
-  ./test_waku_lightpush,
   ./test_wakunode_lightpush,
   # Waku Filter
   ./test_waku_filter_legacy,
@@ -71,9 +64,7 @@ import
   ./test_waku_rendezvous
 
 # Waku Keystore test suite
-import
-  ./test_waku_keystore_keyfile,
-  ./test_waku_keystore
+import ./test_waku_keystore_keyfile, ./test_waku_keystore
 
 ## Wakunode JSON-RPC API test suite
 import
diff --git a/tests/node/test_all.nim b/tests/node/test_all.nim
new file mode 100644
index 000000000..d8a9685de
--- /dev/null
+++ b/tests/node/test_all.nim
@@ -0,0 +1,4 @@
+import
+  ./test_wakunode_filter,
+  ./test_wakunode_lightpush,
+  ./test_wakunode_store
diff --git a/tests/node/test_wakunode_filter.nim b/tests/node/test_wakunode_filter.nim
index 040367093..383b3881e 100644
--- a/tests/node/test_wakunode_filter.nim
+++ b/tests/node/test_wakunode_filter.nim
@@ -1,20 +1,13 @@
 {.used.}
 
 import
-  std/[
-    options,
-    tables,
-    sequtils
-  ],
+  std/[options, tables, sequtils],
   stew/shims/net as stewNet,
   testutils/unittests,
   chronos,
   chronicles,
   os,
-  libp2p/[
-    peerstore,
-    crypto/crypto
-  ]
+  libp2p/[peerstore, crypto/crypto]
 
 import
   ../../../waku/[
@@ -25,14 +18,7 @@ import
     waku_filter_v2/client,
     waku_filter_v2/subscriptions
   ],
-  ../testlib/[
-    common,
-    wakucore,
-    wakunode,
-    testasync,
-    futures,
-    testutils
-  ]
+  ../testlib/[common, wakucore, wakunode, testasync, futures, testutils]
 
 suite "Waku Filter - End to End":
   var client {.threadvar.}: WakuNode
@@ -48,10 +34,11 @@ suite "Waku Filter - End to End":
 
   asyncSetup:
     pushHandlerFuture = newFuture[(string, WakuMessage)]()
-    messagePushHandler = proc(
-      pubsubTopic: PubsubTopic, message: WakuMessage
-    ): Future[void] {.async, closure, gcsafe.} =
-      pushHandlerFuture.complete((pubsubTopic, message))
+    messagePushHandler =
+      proc(pubsubTopic: PubsubTopic, message: WakuMessage): Future[void] {.
+        async, closure, gcsafe
+      .} =
+          pushHandlerFuture.complete((pubsubTopic, message))
 
     pubsubTopic = DefaultPubsubTopic
     contentTopic = DefaultContentTopic
@@ -63,7 +50,8 @@ suite "Waku Filter - End to End":
 
     server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(23450))
     client = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451))
-    clientClone = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451)) # Used for testing client restarts
+    clientClone = newTestWakuNode(clientKey, parseIpAddress("0.0.0.0"), Port(23451))
+      # Used for testing client restarts
 
     await allFutures(server.start(), client.start())
 
@@ -83,9 +71,11 @@ suite "Waku Filter - End to End":
 
   asyncTest "Client Node receives Push from Server Node, via Filter":
     # When a client node subscribes to a filter node
-    let subscribeResponse = await client.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse =
+        await client.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
 
     # Then the subscription is successful
     check:
@@ -94,7 +84,7 @@ suite "Waku Filter - End to End":
       server.wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
     # When sending a message to the subscribed content topic
-    let msg1 = fakeWakuMessage(contentTopic=contentTopic)
+    let msg1 = fakeWakuMessage(contentTopic = contentTopic)
     await server.filterHandleMessage(pubsubTopic, msg1)
 
     # Then the message is pushed to the client
@@ -105,9 +95,11 @@ suite "Waku Filter - End to End":
       pushedMsg1 == msg1
 
     # When unsubscribing from the subscription
-    let unsubscribeResponse = await client.filterUnsubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      unsubscribeResponse =
+        await client.filterUnsubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
 
     # Then the unsubscription is successful
     check:
@@ -116,7 +108,7 @@ suite "Waku Filter - End to End":
 
     # When sending a message to the previously subscribed content topic
     pushHandlerFuture = newPushHandlerFuture() # Clear previous future
-    let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+    let msg2 = fakeWakuMessage(contentTopic = contentTopic)
     await server.filterHandleMessage(pubsubTopic, msg2)
 
     # Then the message is not pushed to the client
@@ -128,16 +120,18 @@ suite "Waku Filter - End to End":
     await server.mountRelay()
 
     # And valid filter subscription
-    let subscribeResponse = await client.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse =
+        await client.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
     require:
       subscribeResponse.isOk()
       server.wakuFilter.subscriptions.subscribedPeerCount() == 1
 
     # When a server node gets a Relay message
-    let msg1 = fakeWakuMessage(contentTopic=contentTopic)
-    await server.publish(some(pubsubTopic), msg1)
+    let msg1 = fakeWakuMessage(contentTopic = contentTopic)
+    discard await server.publish(some(pubsubTopic), msg1)
 
     # Then the message is not sent to the client's filter push handler
     check (not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT))
@@ -154,18 +148,22 @@ suite "Waku Filter - End to End":
     let serverRemotePeerInfo = server.peerInfo.toRemotePeerInfo()
 
     # When a client node subscribes to the server node
-    let subscribeResponse = await client.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse =
+        await client.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
 
     # Then the subscription is successful
     check (not subscribeResponse.isOk())
 
   asyncTest "Filter Client Node can receive messages after subscribing and restarting, via Filter":
     # Given a valid filter subscription
-    let subscribeResponse = await client.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse =
+        await client.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
     require:
       subscribeResponse.isOk()
       server.wakuFilter.subscriptions.subscribedPeerCount() == 1
@@ -175,7 +173,7 @@ suite "Waku Filter - End to End":
     await clientClone.start() # Mimic restart by starting the clone
 
     # When a message is sent to the subscribed content topic, via Filter; without refreshing the subscription
-    let msg = fakeWakuMessage(contentTopic=contentTopic)
+    let msg = fakeWakuMessage(contentTopic = contentTopic)
     await server.filterHandleMessage(pubsubTopic, msg)
 
     # Then the message is pushed to the client
@@ -185,13 +183,15 @@ suite "Waku Filter - End to End":
       pushedMsgPubsubTopic == pubsubTopic
       pushedMsg == msg
 
-  asyncTest "Filter Client Node can't receive messages after subscribing and restarting, via Relay":  # Given the server node has Relay enabled
+  asyncTest "Filter Client Node can't receive messages after subscribing and restarting, via Relay":
     await server.mountRelay()
 
     # Given a valid filter subscription
-    let subscribeResponse = await client.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse =
+        await client.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
     require:
       subscribeResponse.isOk()
       server.wakuFilter.subscriptions.subscribedPeerCount() == 1
@@ -201,24 +201,26 @@ suite "Waku Filter - End to End":
     await clientClone.start() # Mimic restart by starting the clone
 
     # When a message is sent to the subscribed content topic, via Relay
-    let msg = fakeWakuMessage(contentTopic=contentTopic)
-    await server.publish(some(pubsubTopic), msg)
+    let msg = fakeWakuMessage(contentTopic = contentTopic)
+    discard await server.publish(some(pubsubTopic), msg)
 
     # Then the message is not sent to the client's filter push handler
     check (not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT))
 
     # Given the client refreshes the subscription
-    let subscribeResponse2 = await clientClone.filterSubscribe(
-      some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
-    )
+    let
+      subscribeResponse2 =
+        await clientClone.filterSubscribe(
+          some(pubsubTopic), contentTopicSeq, serverRemotePeerInfo
+        )
     check:
       subscribeResponse2.isOk()
       server.wakuFilter.subscriptions.subscribedPeerCount() == 1
 
     # When a message is sent to the subscribed content topic, via Relay
     pushHandlerFuture = newPushHandlerFuture()
-    let msg2 = fakeWakuMessage(contentTopic=contentTopic)
-    await server.publish(some(pubsubTopic), msg2)
+    let msg2 = fakeWakuMessage(contentTopic = contentTopic)
+    discard await server.publish(some(pubsubTopic), msg2)
 
     # Then the message is not sent to the client's filter push handler
     check (not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT))
diff --git a/tests/node/test_wakunode_lightpush.nim b/tests/node/test_wakunode_lightpush.nim
new file mode 100644
index 000000000..0a8141c15
--- /dev/null
+++ b/tests/node/test_wakunode_lightpush.nim
@@ -0,0 +1,93 @@
+{.used.}
+
+import
+  std/[options, tables, sequtils],
+  stew/shims/net as stewNet,
+  testutils/unittests,
+  chronos,
+  chronicles,
+  os,
+  libp2p/[peerstore, crypto/crypto]
+
+import
+  ../../../waku/[
+    waku_core,
+    node/peer_manager,
+    node/waku_node,
+    waku_filter_v2,
+    waku_filter_v2/client,
+    waku_filter_v2/subscriptions,
+    waku_lightpush,
+    waku_lightpush/common,
+    waku_lightpush/client,
+    waku_lightpush/protocol_metrics,
+    waku_lightpush/rpc
+  ],
+  ../testlib/[assertions, common, wakucore, wakunode, testasync, futures, testutils]
+
+suite "Waku Lightpush - End To End":
+  var
+    handlerFuture {.threadvar.}: Future[(PubsubTopic, WakuMessage)]
+    handler {.threadvar.}: PushMessageHandler
+
+    server {.threadvar.}: WakuNode
+    client {.threadvar.}: WakuNode
+
+    serverRemotePeerInfo {.threadvar.}: RemotePeerInfo
+    pubsubTopic {.threadvar.}: PubsubTopic
+    contentTopic {.threadvar.}: ContentTopic
+    message {.threadvar.}: WakuMessage
+
+  asyncSetup:
+    handlerFuture = newPushHandlerFuture()
+    handler =
+      proc(
+        peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage
+      ): Future[WakuLightPushResult[void]] {.async.} =
+          handlerFuture.complete((pubsubTopic, message))
+          return ok()
+
+    let
+      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))
+
+    await allFutures(server.start(), client.start())
+    await server.start()
+
+    waitFor server.mountRelay()
+    waitFor server.mountLightpush()
+    client.mountLightpushClient()
+
+    serverRemotePeerInfo = server.peerInfo.toRemotePeerInfo()
+    pubsubTopic = DefaultPubsubTopic
+    contentTopic = DefaultContentTopic
+    message = fakeWakuMessage()
+
+  asyncTeardown:
+    await server.stop()
+
+  suite "Assessment of Message Relaying Mechanisms":
+    asyncTest "Via 11/WAKU2-RELAY from Relay/Full Node":
+      # Given a light lightpush client
+      let
+        lightpushClient =
+          newTestWakuNode(
+            generateSecp256k1Key(), ValidIpAddress.init("0.0.0.0"), Port(0)
+          )
+      lightpushClient.mountLightpushClient()
+
+      # When the client publishes a message
+      let
+        publishResponse =
+          await lightpushClient.lightpushPublish(
+            some(pubsubTopic), message, serverRemotePeerInfo
+          )
+
+      if not publishResponse.isOk():
+        echo "Publish failed: ", publishResponse.error()
+
+      # Then the message is relayed to the server
+      assertResultOk publishResponse
diff --git a/tests/node/test_wakunode_store.nim b/tests/node/test_wakunode_store.nim
index d0e44634c..22153de29 100644
--- a/tests/node/test_wakunode_store.nim
+++ b/tests/node/test_wakunode_store.nim
@@ -1,4 +1,4 @@
-{.used.}  
+{.used.}
 
 import
   std/options,
@@ -9,6 +9,7 @@ import
 
 import
   ../../../waku/[
+    common/paging,
     node/waku_node,
     node/peer_manager,
     waku_core,
@@ -20,15 +21,7 @@ import
   ],
   ../waku_store/store_utils,
   ../waku_archive/archive_utils,
-  ../testlib/[
-    common,
-    wakucore,
-    wakunode,
-    testasync,
-    futures,
-    testutils
-  ]
-
+  ../testlib/[common, wakucore, wakunode, testasync, futures, testutils]
 
 suite "Waku Store - End to End - Sorted Archive":
   var pubsubTopic {.threadvar.}: PubsubTopic
@@ -43,7 +36,7 @@ suite "Waku Store - End to End - Sorted Archive":
 
   var archiveDriver {.threadvar.}: ArchiveDriver
   var serverRemotePeerInfo {.threadvar.}: RemotePeerInfo
-  var clientPeerId {.threadvar.}: PeerId  
+  var clientPeerId {.threadvar.}: PeerId
 
   asyncSetup:
     pubsubTopic = DefaultPubsubTopic
@@ -51,25 +44,27 @@ suite "Waku Store - End to End - Sorted Archive":
     contentTopicSeq = @[contentTopic]
 
     let timeOrigin = now()
-    archiveMessages = @[
-      fakeWakuMessage(@[byte 00], ts=ts(00, timeOrigin)),
-      fakeWakuMessage(@[byte 01], ts=ts(10, timeOrigin)),
-      fakeWakuMessage(@[byte 02], ts=ts(20, timeOrigin)),
-      fakeWakuMessage(@[byte 03], ts=ts(30, timeOrigin)),
-      fakeWakuMessage(@[byte 04], ts=ts(40, timeOrigin)),
-      fakeWakuMessage(@[byte 05], ts=ts(50, timeOrigin)),
-      fakeWakuMessage(@[byte 06], ts=ts(60, timeOrigin)),
-      fakeWakuMessage(@[byte 07], ts=ts(70, timeOrigin)),
-      fakeWakuMessage(@[byte 08], ts=ts(80, timeOrigin)),
-      fakeWakuMessage(@[byte 09], ts=ts(90, timeOrigin))
-    ]
+    archiveMessages =
+      @[
+        fakeWakuMessage(@[byte 00], ts = ts(00, timeOrigin)),
+        fakeWakuMessage(@[byte 01], ts = ts(10, timeOrigin)),
+        fakeWakuMessage(@[byte 02], ts = ts(20, timeOrigin)),
+        fakeWakuMessage(@[byte 03], ts = ts(30, timeOrigin)),
+        fakeWakuMessage(@[byte 04], ts = ts(40, timeOrigin)),
+        fakeWakuMessage(@[byte 05], ts = ts(50, timeOrigin)),
+        fakeWakuMessage(@[byte 06], ts = ts(60, timeOrigin)),
+        fakeWakuMessage(@[byte 07], ts = ts(70, timeOrigin)),
+        fakeWakuMessage(@[byte 08], ts = ts(80, timeOrigin)),
+        fakeWakuMessage(@[byte 09], ts = ts(90, timeOrigin))
+      ]
 
-    historyQuery = HistoryQuery(
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    historyQuery =
+      HistoryQuery(
+        pubsubTopic: some(pubsubTopic),
+        contentTopics: contentTopicSeq,
+        direction: PagingDirection.Forward,
+        pageSize: 5,
+      )
 
     let
       serverKey = generateSecp256k1Key()
@@ -103,16 +98,19 @@ suite "Waku Store - End to End - Sorted Archive":
         queryResponse.get().messages == archiveMessages[0..<5]
 
       # Given the next query
-      var otherHistoryQuery = HistoryQuery(
-        cursor: queryResponse.get().cursor,
-        pubsubTopic: some(pubsubTopic),
-        contentTopics: contentTopicSeq,
-        direction: true,
-        pageSize: 5
-      )
+      var
+        otherHistoryQuery =
+          HistoryQuery(
+            cursor: queryResponse.get().cursor,
+            pubsubTopic: some(pubsubTopic),
+            contentTopics: contentTopicSeq,
+            direction: PagingDirection.FORWARD,
+            pageSize: 5,
+          )
 
       # When making the next history query
-      let otherQueryResponse = await client.query(otherHistoryQuery, serverRemotePeerInfo)
+      let
+        otherQueryResponse = await client.query(otherHistoryQuery, serverRemotePeerInfo)
 
       # Then the response contains the messages
       check:
@@ -120,7 +118,7 @@ suite "Waku Store - End to End - Sorted Archive":
 
     asyncTest "Backward Pagination":
       # Given the history query is backward
-      historyQuery.direction = false
+      historyQuery.direction = PagingDirection.BACKWARD
 
       # When making a history query
       let queryResponse = await client.query(historyQuery, serverRemotePeerInfo)
@@ -130,16 +128,19 @@ suite "Waku Store - End to End - Sorted Archive":
         queryResponse.get().messages == archiveMessages[5..<10]
 
       # Given the next query
-      var nextHistoryQuery = HistoryQuery(
-        cursor: queryResponse.get().cursor,
-        pubsubTopic: some(pubsubTopic),
-        contentTopics: contentTopicSeq,
-        direction: false,
-        pageSize: 5
-      )
+      var
+        nextHistoryQuery =
+          HistoryQuery(
+            cursor: queryResponse.get().cursor,
+            pubsubTopic: some(pubsubTopic),
+            contentTopics: contentTopicSeq,
+            direction: PagingDirection.BACKWARD,
+            pageSize: 5,
+          )
 
       # When making the next history query
-      let otherQueryResponse = await client.query(nextHistoryQuery, serverRemotePeerInfo)
+      let
+        otherQueryResponse = await client.query(nextHistoryQuery, serverRemotePeerInfo)
 
       # Then the response contains the messages
       check:
@@ -158,13 +159,15 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse1.get().messages == archiveMessages[0..<2]
 
         # Given the next query (2/5)
-        let historyQuery2 = HistoryQuery(
-          cursor: queryResponse1.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 2
-        )
+        let
+          historyQuery2 =
+            HistoryQuery(
+              cursor: queryResponse1.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 2,
+            )
 
         # When making the next history query
         let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
@@ -174,13 +177,15 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse2.get().messages == archiveMessages[2..<4]
 
         # Given the next query (3/5)
-        let historyQuery3 = HistoryQuery(
-          cursor: queryResponse2.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 2
-        )
+        let
+          historyQuery3 =
+            HistoryQuery(
+              cursor: queryResponse2.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 2,
+            )
 
         # When making the next history query
         let queryResponse3 = await client.query(historyQuery3, serverRemotePeerInfo)
@@ -188,15 +193,17 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the messages
         check:
           queryResponse3.get().messages == archiveMessages[4..<6]
-        
+
         # Given the next query (4/5)
-        let historyQuery4 = HistoryQuery(
-          cursor: queryResponse3.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 2
-        )
+        let
+          historyQuery4 =
+            HistoryQuery(
+              cursor: queryResponse3.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 2,
+            )
 
         # When making the next history query
         let queryResponse4 = await client.query(historyQuery4, serverRemotePeerInfo)
@@ -206,13 +213,15 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse4.get().messages == archiveMessages[6..<8]
 
         # Given the next query (5/5)
-        let historyQuery5 = HistoryQuery(
-          cursor: queryResponse4.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 2
-        )
+        let
+          historyQuery5 =
+            HistoryQuery(
+              cursor: queryResponse4.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 2,
+            )
 
         # When making the next history query
         let queryResponse5 = await client.query(historyQuery5, serverRemotePeerInfo)
@@ -220,7 +229,7 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the messages
         check:
           queryResponse5.get().messages == archiveMessages[8..<10]
-      
+
       asyncTest "Pagination with Large Page Size":
         # Given the first query (1/2)
         historyQuery.pageSize = 8
@@ -231,15 +240,17 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the messages
         check:
           queryResponse1.get().messages == archiveMessages[0..<8]
-        
+
         # Given the next query (2/2)
-        let historyQuery2 = HistoryQuery(
-          cursor: queryResponse1.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 8
-        )
+        let
+          historyQuery2 =
+            HistoryQuery(
+              cursor: queryResponse1.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 8,
+            )
 
         # When making the next history query
         let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
@@ -247,7 +258,7 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the messages
         check:
           queryResponse2.get().messages == archiveMessages[8..<10]
-        
+
       asyncTest "Pagination with Excessive Page Size":
         # Given the first query (1/1)
         historyQuery.pageSize = 100
@@ -271,13 +282,15 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse1.get().messages == archiveMessages[0..<2]
 
         # Given the next query (2/3)
-        let historyQuery2 = HistoryQuery(
-          cursor: queryResponse1.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 4
-        )
+        let
+          historyQuery2 =
+            HistoryQuery(
+              cursor: queryResponse1.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 4,
+            )
 
         # When making the next history query
         let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
@@ -287,13 +300,15 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse2.get().messages == archiveMessages[2..<6]
 
         # Given the next query (3/3)
-        let historyQuery3 = HistoryQuery(
-          cursor: queryResponse2.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 6
-        )
+        let
+          historyQuery3 =
+            HistoryQuery(
+              cursor: queryResponse2.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 6,
+            )
 
         # When making the next history query
         let queryResponse3 = await client.query(historyQuery3, serverRemotePeerInfo)
@@ -305,15 +320,18 @@ suite "Waku Store - End to End - Sorted Archive":
       asyncTest "Pagination with Zero Page Size (Behaves as DefaultPageSize)":
         # Given a message list of size higher than the default page size
         let currentStoreLen = uint((await archiveDriver.getMessagesCount()).get())
-        assert archive.DefaultPageSize > currentStoreLen, "This test requires a store with more than (DefaultPageSize) messages"
+        assert archive.DefaultPageSize > currentStoreLen,
+          "This test requires a store with more than (DefaultPageSize) messages"
         let missingMessagesAmount = archive.DefaultPageSize - currentStoreLen + 5
 
         let lastMessageTimestamp = archiveMessages[archiveMessages.len - 1].timestamp
         var extraMessages: seq[WakuMessage] = @[]
         for i in 0..<missingMessagesAmount:
-          let 
-            timestampOffset = 10 * int(i + 1) # + 1 to avoid collision with existing messages
-            message: WakuMessage = fakeWakuMessage(@[byte i], ts=ts(timestampOffset, lastMessageTimestamp))
+          let
+            timestampOffset = 10 * int(i + 1)
+              # + 1 to avoid collision with existing messages
+            message: WakuMessage =
+              fakeWakuMessage(@[byte i], ts = ts(timestampOffset, lastMessageTimestamp))
           extraMessages.add(message)
         discard archiveDriver.put(pubsubTopic, extraMessages)
 
@@ -328,46 +346,53 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the archive.DefaultPageSize messages
         check:
           queryResponse1.get().messages == totalMessages[0..<archive.DefaultPageSize]
-        
+
         # Given the next query (2/2)
-        let historyQuery2 = HistoryQuery(
-          cursor: queryResponse1.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 0
-        )
+        let
+          historyQuery2 =
+            HistoryQuery(
+              cursor: queryResponse1.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 0,
+            )
 
         # When making the next history query
         let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
 
         # Then the response contains the remaining messages
         check:
-          queryResponse2.get().messages == totalMessages[archive.DefaultPageSize..<archive.DefaultPageSize + 5]
+          queryResponse2.get().messages ==
+            totalMessages[archive.DefaultPageSize..<archive.DefaultPageSize + 5]
 
       asyncTest "Pagination with Default Page Size":
         # Given a message list of size higher than the default page size
         let currentStoreLen = uint((await archiveDriver.getMessagesCount()).get())
-        assert archive.DefaultPageSize > currentStoreLen, "This test requires a store with more than (DefaultPageSize) messages"
+        assert archive.DefaultPageSize > currentStoreLen,
+          "This test requires a store with more than (DefaultPageSize) messages"
         let missingMessagesAmount = archive.DefaultPageSize - currentStoreLen + 5
 
         let lastMessageTimestamp = archiveMessages[archiveMessages.len - 1].timestamp
         var extraMessages: seq[WakuMessage] = @[]
         for i in 0..<missingMessagesAmount:
-          let 
-            timestampOffset = 10 * int(i + 1) # + 1 to avoid collision with existing messages
-            message: WakuMessage = fakeWakuMessage(@[byte i], ts=ts(timestampOffset, lastMessageTimestamp))
+          let
+            timestampOffset = 10 * int(i + 1)
+              # + 1 to avoid collision with existing messages
+            message: WakuMessage =
+              fakeWakuMessage(@[byte i], ts = ts(timestampOffset, lastMessageTimestamp))
           extraMessages.add(message)
         discard archiveDriver.put(pubsubTopic, extraMessages)
 
         let totalMessages = archiveMessages & extraMessages
 
         # Given a query with default page size (1/2)
-        historyQuery = HistoryQuery(
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true
-        )
+        historyQuery =
+          HistoryQuery(
+            pubsubTopic: some(pubsubTopic),
+            contentTopics: contentTopicSeq,
+            direction: PagingDirection.FORWARD,
+          )
 
         # When making a history query
         let queryResponse = await client.query(historyQuery, serverRemotePeerInfo)
@@ -377,19 +402,22 @@ suite "Waku Store - End to End - Sorted Archive":
           queryResponse.get().messages == totalMessages[0..<archive.DefaultPageSize]
 
         # Given the next query (2/2)
-        let historyQuery2 = HistoryQuery(
-          cursor: queryResponse.get().cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true
-        )
+        let
+          historyQuery2 =
+            HistoryQuery(
+              cursor: queryResponse.get().cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+            )
 
         # When making the next history query
         let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
 
         # Then the response contains the messages
         check:
-          queryResponse2.get().messages == totalMessages[archive.DefaultPageSize..<archive.DefaultPageSize + 5]
+          queryResponse2.get().messages ==
+            totalMessages[archive.DefaultPageSize..<archive.DefaultPageSize + 5]
 
     suite "Pagination with Different Cursors":
       asyncTest "Starting Cursor":
@@ -430,17 +458,20 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains no messages
         check:
           queryResponse.get().messages.len == 0
-    
+
     suite "Message Sorting":
       asyncTest "Cursor Reusability Across Nodes":
         # Given a different server node with the same archive
         let
-          otherArchiveDriverWithMessages = newArchiveDriverWithMessages(pubsubTopic, archiveMessages)
+          otherArchiveDriverWithMessages =
+            newArchiveDriverWithMessages(pubsubTopic, archiveMessages)
           otherServerKey = generateSecp256k1Key()
-          otherServer = newTestWakuNode(otherServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
-          mountOtherArchiveResult = otherServer.mountArchive(otherArchiveDriverWithMessages)    
+          otherServer =
+            newTestWakuNode(otherServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
+          mountOtherArchiveResult =
+            otherServer.mountArchive(otherArchiveDriverWithMessages)
         assert mountOtherArchiveResult.isOk()
-        
+
         waitFor otherServer.mountStore()
 
         waitFor otherServer.start()
@@ -452,19 +483,23 @@ suite "Waku Store - End to End - Sorted Archive":
         # Then the response contains the messages
         check:
           queryResponse.get().messages == archiveMessages[0..<5]
-        
+
         # Given the cursor from the first query
         let cursor = queryResponse.get().cursor
 
         # When making a history query to the second server node
-        let otherHistoryQuery = HistoryQuery(
-          cursor: cursor,
-          pubsubTopic: some(pubsubTopic),
-          contentTopics: contentTopicSeq,
-          direction: true,
-          pageSize: 5
-        )
-        let otherQueryResponse = await client.query(otherHistoryQuery, otherServerRemotePeerInfo)
+        let
+          otherHistoryQuery =
+            HistoryQuery(
+              cursor: cursor,
+              pubsubTopic: some(pubsubTopic),
+              contentTopics: contentTopicSeq,
+              direction: PagingDirection.FORWARD,
+              pageSize: 5,
+            )
+        let
+          otherQueryResponse =
+            await client.query(otherHistoryQuery, otherServerRemotePeerInfo)
 
         # Then the response contains the remaining messages
         check:
@@ -473,7 +508,6 @@ suite "Waku Store - End to End - Sorted Archive":
         # Cleanup
         waitFor otherServer.stop()
 
-
 suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
   var pubsubTopic {.threadvar.}: PubsubTopic
   var contentTopic {.threadvar.}: ContentTopic
@@ -492,28 +526,30 @@ suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
     contentTopic = DefaultContentTopic
     contentTopicSeq = @[contentTopic]
 
-    historyQuery = HistoryQuery(
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    historyQuery =
+      HistoryQuery(
+        pubsubTopic: some(pubsubTopic),
+        contentTopics: contentTopicSeq,
+        direction: PagingDirection.FORWARD,
+        pageSize: 5,
+      )
 
     let timeOrigin = now()
-    unsortedArchiveMessages = @[                          # SortIndex (by timestamp and digest)
-      fakeWakuMessage(@[byte 00], ts=ts(00, timeOrigin)), # 1
-      fakeWakuMessage(@[byte 03], ts=ts(00, timeOrigin)), # 2
-      fakeWakuMessage(@[byte 08], ts=ts(00, timeOrigin)), # 0
-      fakeWakuMessage(@[byte 07], ts=ts(10, timeOrigin)), # 4
-      fakeWakuMessage(@[byte 02], ts=ts(10, timeOrigin)), # 3
-      fakeWakuMessage(@[byte 09], ts=ts(10, timeOrigin)), # 5
-      fakeWakuMessage(@[byte 06], ts=ts(20, timeOrigin)), # 6
-      fakeWakuMessage(@[byte 01], ts=ts(20, timeOrigin)), # 9
-      fakeWakuMessage(@[byte 04], ts=ts(20, timeOrigin)), # 7
-      fakeWakuMessage(@[byte 05], ts=ts(20, timeOrigin))  # 8
-    ]
+    unsortedArchiveMessages =
+      @[ # SortIndex (by timestamp and digest)
+        fakeWakuMessage(@[byte 00], ts = ts(00, timeOrigin)), # 1
+        fakeWakuMessage(@[byte 03], ts = ts(00, timeOrigin)), # 2
+        fakeWakuMessage(@[byte 08], ts = ts(00, timeOrigin)), # 0
+        fakeWakuMessage(@[byte 07], ts = ts(10, timeOrigin)), # 4
+        fakeWakuMessage(@[byte 02], ts = ts(10, timeOrigin)), # 3
+        fakeWakuMessage(@[byte 09], ts = ts(10, timeOrigin)), # 5
+        fakeWakuMessage(@[byte 06], ts = ts(20, timeOrigin)), # 6
+        fakeWakuMessage(@[byte 01], ts = ts(20, timeOrigin)), # 9
+        fakeWakuMessage(@[byte 04], ts = ts(20, timeOrigin)), # 7
+        fakeWakuMessage(@[byte 05], ts = ts(20, timeOrigin)) # 8
+      ]
 
-    let 
+    let
       serverKey = generateSecp256k1Key()
       clientKey = generateSecp256k1Key()
 
@@ -521,8 +557,10 @@ suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
     client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
 
     let
-      unsortedArchiveDriverWithMessages = newArchiveDriverWithMessages(pubsubTopic, unsortedArchiveMessages)
-      mountUnsortedArchiveResult = server.mountArchive(unsortedArchiveDriverWithMessages)    
+      unsortedArchiveDriverWithMessages =
+        newArchiveDriverWithMessages(pubsubTopic, unsortedArchiveMessages)
+      mountUnsortedArchiveResult =
+        server.mountArchive(unsortedArchiveDriverWithMessages)
 
     assert mountUnsortedArchiveResult.isOk()
 
@@ -542,40 +580,44 @@ suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
 
     # Then the response contains the messages
     check:
-      queryResponse.get().messages == @[
-        unsortedArchiveMessages[2],
-        unsortedArchiveMessages[0],
-        unsortedArchiveMessages[1],
-        unsortedArchiveMessages[4],
-        unsortedArchiveMessages[3]
-      ]
-    
+      queryResponse.get().messages ==
+        @[
+          unsortedArchiveMessages[2],
+          unsortedArchiveMessages[0],
+          unsortedArchiveMessages[1],
+          unsortedArchiveMessages[4],
+          unsortedArchiveMessages[3]
+        ]
+
     # Given the next query
-    var historyQuery2 = HistoryQuery(
-      cursor: queryResponse.get().cursor,
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    var
+      historyQuery2 =
+        HistoryQuery(
+          cursor: queryResponse.get().cursor,
+          pubsubTopic: some(pubsubTopic),
+          contentTopics: contentTopicSeq,
+          direction: PagingDirection.FORWARD,
+          pageSize: 5,
+        )
 
     # When making the next history query
     let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
 
     # Then the response contains the messages
     check:
-      queryResponse2.get().messages == @[
-        unsortedArchiveMessages[5],
-        unsortedArchiveMessages[6],
-        unsortedArchiveMessages[8],
-        unsortedArchiveMessages[9],
-        unsortedArchiveMessages[7]
-      ]
+      queryResponse2.get().messages ==
+        @[
+          unsortedArchiveMessages[5],
+          unsortedArchiveMessages[6],
+          unsortedArchiveMessages[8],
+          unsortedArchiveMessages[9],
+          unsortedArchiveMessages[7]
+        ]
 
   asyncTest "Backward pagination with Ascending Sorting":
     # Given a history query with backward pagination
     let cursor = computeHistoryCursor(pubsubTopic, unsortedArchiveMessages[4])
-    historyQuery.direction = false
+    historyQuery.direction = PagingDirection.BACKWARD
     historyQuery.cursor = some(cursor)
 
     # When making a history query
@@ -583,16 +625,17 @@ suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
 
     # Then the response contains the messages
     check:
-      queryResponse.get().messages == @[
-        unsortedArchiveMessages[2],
-        unsortedArchiveMessages[0],
-        unsortedArchiveMessages[1]
-      ]
-  
+      queryResponse.get().messages ==
+        @[
+          unsortedArchiveMessages[2],
+          unsortedArchiveMessages[0],
+          unsortedArchiveMessages[1]
+        ]
+
   asyncTest "Forward Pagination with Ascending Sorting":
     # Given a history query with forward pagination
     let cursor = computeHistoryCursor(pubsubTopic, unsortedArchiveMessages[4])
-    historyQuery.direction = true
+    historyQuery.direction = PagingDirection.FORWARD
     historyQuery.cursor = some(cursor)
 
     # When making a history query
@@ -600,14 +643,14 @@ suite "Waku Store - End to End - Unsorted Archive with provided Timestamp":
 
     # Then the response contains the messages
     check:
-      queryResponse.get().messages == @[
-        unsortedArchiveMessages[3],
-        unsortedArchiveMessages[5],
-        unsortedArchiveMessages[6],
-        unsortedArchiveMessages[8],
-        unsortedArchiveMessages[9]
-      ]
-
+      queryResponse.get().messages ==
+        @[
+          unsortedArchiveMessages[3],
+          unsortedArchiveMessages[5],
+          unsortedArchiveMessages[6],
+          unsortedArchiveMessages[8],
+          unsortedArchiveMessages[9]
+        ]
 
 suite "Waku Store - End to End - Unsorted Archive without provided Timestamp":
   var pubsubTopic {.threadvar.}: PubsubTopic
@@ -627,27 +670,29 @@ suite "Waku Store - End to End - Unsorted Archive without provided Timestamp":
     contentTopic = DefaultContentTopic
     contentTopicSeq = @[contentTopic]
 
-    historyQuery = HistoryQuery(
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    historyQuery =
+      HistoryQuery(
+        pubsubTopic: some(pubsubTopic),
+        contentTopics: contentTopicSeq,
+        direction: PagingDirection.FORWARD,
+        pageSize: 5,
+      )
 
-    unsortedArchiveMessages = @[  # Not providing explicit timestamp means it will be set in "arrive" order
-      fakeWakuMessage(@[byte 09]),
-      fakeWakuMessage(@[byte 07]),
-      fakeWakuMessage(@[byte 05]),
-      fakeWakuMessage(@[byte 03]),
-      fakeWakuMessage(@[byte 01]),
-      fakeWakuMessage(@[byte 00]),
-      fakeWakuMessage(@[byte 02]),
-      fakeWakuMessage(@[byte 04]),
-      fakeWakuMessage(@[byte 06]),
-      fakeWakuMessage(@[byte 08])
-    ]
+    unsortedArchiveMessages =
+      @[ # Not providing explicit timestamp means it will be set in "arrive" order
+        fakeWakuMessage(@[byte 09]),
+        fakeWakuMessage(@[byte 07]),
+        fakeWakuMessage(@[byte 05]),
+        fakeWakuMessage(@[byte 03]),
+        fakeWakuMessage(@[byte 01]),
+        fakeWakuMessage(@[byte 00]),
+        fakeWakuMessage(@[byte 02]),
+        fakeWakuMessage(@[byte 04]),
+        fakeWakuMessage(@[byte 06]),
+        fakeWakuMessage(@[byte 08])
+      ]
 
-    let 
+    let
       serverKey = generateSecp256k1Key()
       clientKey = generateSecp256k1Key()
 
@@ -655,8 +700,10 @@ suite "Waku Store - End to End - Unsorted Archive without provided Timestamp":
     client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
 
     let
-      unsortedArchiveDriverWithMessages = newArchiveDriverWithMessages(pubsubTopic, unsortedArchiveMessages)
-      mountUnsortedArchiveResult = server.mountArchive(unsortedArchiveDriverWithMessages)    
+      unsortedArchiveDriverWithMessages =
+        newArchiveDriverWithMessages(pubsubTopic, unsortedArchiveMessages)
+      mountUnsortedArchiveResult =
+        server.mountArchive(unsortedArchiveDriverWithMessages)
 
     assert mountUnsortedArchiveResult.isOk()
 
@@ -669,43 +716,46 @@ suite "Waku Store - End to End - Unsorted Archive without provided Timestamp":
 
   asyncTeardown:
     waitFor allFutures(client.stop(), server.stop())
-  
+
   asyncTest "Sorting using receiverTime":
     # When making a history query
     let queryResponse = await client.query(historyQuery, serverRemotePeerInfo)
 
     # Then the response contains the messages
     check:
-      queryResponse.get().messages == @[
-        unsortedArchiveMessages[0],
-        unsortedArchiveMessages[1],
-        unsortedArchiveMessages[2],
-        unsortedArchiveMessages[3],
-        unsortedArchiveMessages[4]
-      ]
-    
+      queryResponse.get().messages ==
+        @[
+          unsortedArchiveMessages[0],
+          unsortedArchiveMessages[1],
+          unsortedArchiveMessages[2],
+          unsortedArchiveMessages[3],
+          unsortedArchiveMessages[4]
+        ]
+
     # Given the next query
-    var historyQuery2 = HistoryQuery(
-      cursor: queryResponse.get().cursor,
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    var
+      historyQuery2 =
+        HistoryQuery(
+          cursor: queryResponse.get().cursor,
+          pubsubTopic: some(pubsubTopic),
+          contentTopics: contentTopicSeq,
+          direction: PagingDirection.FORWARD,
+          pageSize: 5,
+        )
 
     # When making the next history query
     let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
 
     # Then the response contains the messages
     check:
-      queryResponse2.get().messages == @[
-        unsortedArchiveMessages[5],
-        unsortedArchiveMessages[6],
-        unsortedArchiveMessages[7],
-        unsortedArchiveMessages[8],
-        unsortedArchiveMessages[9]
-      ]
-
+      queryResponse2.get().messages ==
+        @[
+          unsortedArchiveMessages[5],
+          unsortedArchiveMessages[6],
+          unsortedArchiveMessages[7],
+          unsortedArchiveMessages[8],
+          unsortedArchiveMessages[9]
+        ]
 
 suite "Waku Store - End to End - Archive with Multiple Topics":
   var pubsubTopic {.threadvar.}: PubsubTopic
@@ -717,7 +767,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
   var contentTopicSeq {.threadvar.}: seq[ContentTopic]
 
   var historyQuery {.threadvar.}: HistoryQuery
-  var originTs {.threadvar.}: proc(offset: int): Timestamp {.gcsafe, closure.}
+  var originTs {.threadvar.}: proc(offset: int): Timestamp {.gcsafe, raises: [].}
   var archiveMessages {.threadvar.}: seq[WakuMessage]
 
   var server {.threadvar.}: WakuNode
@@ -732,31 +782,39 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
     contentTopicB = "topicB"
     contentTopicC = "topicC"
     contentTopicSpecials = "!@#$%^&*()_+"
-    contentTopicSeq = @[contentTopic, contentTopicB, contentTopicC, contentTopicSpecials]
+    contentTopicSeq =
+      @[contentTopic, contentTopicB, contentTopicC, contentTopicSpecials]
 
-    historyQuery = HistoryQuery(
-      pubsubTopic: some(pubsubTopic),
-      contentTopics: contentTopicSeq,
-      direction: true,
-      pageSize: 5
-    )
+    historyQuery =
+      HistoryQuery(
+        pubsubTopic: some(pubsubTopic),
+        contentTopics: contentTopicSeq,
+        direction: PagingDirection.FORWARD,
+        pageSize: 5,
+      )
 
     let timeOrigin = now()
-    originTs = proc(offset = 0): Timestamp {.gcsafe, closure.} =
+
+    proc myOriginTs(offset = 0): Timestamp {.gcsafe, raises: [].} =
       ts(offset, timeOrigin)
 
-    archiveMessages = @[
-      fakeWakuMessage(@[byte 00], ts=originTs(00), contentTopic=contentTopic),
-      fakeWakuMessage(@[byte 01], ts=originTs(10), contentTopic=contentTopicB),
-      fakeWakuMessage(@[byte 02], ts=originTs(20), contentTopic=contentTopicC),
-      fakeWakuMessage(@[byte 03], ts=originTs(30), contentTopic=contentTopic),
-      fakeWakuMessage(@[byte 04], ts=originTs(40), contentTopic=contentTopicB),
-      fakeWakuMessage(@[byte 05], ts=originTs(50), contentTopic=contentTopicC),
-      fakeWakuMessage(@[byte 06], ts=originTs(60), contentTopic=contentTopic),
-      fakeWakuMessage(@[byte 07], ts=originTs(70), contentTopic=contentTopicB),
-      fakeWakuMessage(@[byte 08], ts=originTs(80), contentTopic=contentTopicC),
-      fakeWakuMessage(@[byte 09], ts=originTs(90), contentTopic=contentTopicSpecials) 
-    ]
+    originTs = myOriginTs
+
+    archiveMessages =
+      @[
+        fakeWakuMessage(@[byte 00], ts = originTs(00), contentTopic = contentTopic),
+        fakeWakuMessage(@[byte 01], ts = originTs(10), contentTopic = contentTopicB),
+        fakeWakuMessage(@[byte 02], ts = originTs(20), contentTopic = contentTopicC),
+        fakeWakuMessage(@[byte 03], ts = originTs(30), contentTopic = contentTopic),
+        fakeWakuMessage(@[byte 04], ts = originTs(40), contentTopic = contentTopicB),
+        fakeWakuMessage(@[byte 05], ts = originTs(50), contentTopic = contentTopicC),
+        fakeWakuMessage(@[byte 06], ts = originTs(60), contentTopic = contentTopic),
+        fakeWakuMessage(@[byte 07], ts = originTs(70), contentTopic = contentTopicB),
+        fakeWakuMessage(@[byte 08], ts = originTs(80), contentTopic = contentTopicC),
+        fakeWakuMessage(
+          @[byte 09], ts = originTs(90), contentTopic = contentTopicSpecials
+        )
+      ]
 
     let
       serverKey = generateSecp256k1Key()
@@ -765,13 +823,12 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
     server = newTestWakuNode(serverKey, ValidIpAddress.init("0.0.0.0"), Port(0))
     client = newTestWakuNode(clientKey, ValidIpAddress.init("0.0.0.0"), Port(0))
 
-    let archiveDriver = newSqliteArchiveDriver(
-      ).put(
-        pubsubTopic, archiveMessages[0..<6]
-      ).put(
-        pubsubTopicB, archiveMessages[6..<10]
-      )
-    let mountUnsortedArchiveResult = server.mountArchive(archiveDriver)    
+    let
+      archiveDriver =
+        newSqliteArchiveDriver().put(pubsubTopic, archiveMessages[0..<6]).put(
+          pubsubTopicB, archiveMessages[6..<10]
+        )
+    let mountUnsortedArchiveResult = server.mountArchive(archiveDriver)
 
     assert mountUnsortedArchiveResult.isOk()
 
@@ -795,10 +852,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[0],
-          archiveMessages[3]
-        ]
+        queryResponse.get().messages == @[archiveMessages[0], archiveMessages[3]]
 
     asyncTest "Multiple Content Filters":
       # Given a history query with multiple content filtering
@@ -809,12 +863,13 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[0],
-          archiveMessages[1],
-          archiveMessages[3],
-          archiveMessages[4]
-        ]
+        queryResponse.get().messages ==
+          @[
+            archiveMessages[0],
+            archiveMessages[1],
+            archiveMessages[3],
+            archiveMessages[4]
+          ]
 
     asyncTest "Empty Content Filtering":
       # Given a history query with empty content filtering
@@ -826,15 +881,17 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       # Then the response contains the messages
       check:
         queryResponse.get().messages == archiveMessages[0..<5]
-      
+
       # Given the next query
-      let historyQuery2 = HistoryQuery(
-        cursor: queryResponse.get().cursor,
-        pubsubTopic: none(PubsubTopic),
-        contentTopics: contentTopicSeq,
-        direction: true,
-        pageSize: 5
-      )
+      let
+        historyQuery2 =
+          HistoryQuery(
+            cursor: queryResponse.get().cursor,
+            pubsubTopic: none(PubsubTopic),
+            contentTopics: contentTopicSeq,
+            direction: PagingDirection.FORWARD,
+            pageSize: 5,
+          )
 
       # When making the next history query
       let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
@@ -875,12 +932,13 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[6],
-          archiveMessages[7],
-          archiveMessages[8],
-          archiveMessages[9]
-        ]
+        queryResponse.get().messages ==
+          @[
+            archiveMessages[6],
+            archiveMessages[7],
+            archiveMessages[8],
+            archiveMessages[9]
+          ]
 
     asyncTest "PubsubTopic Left Empty":
       # Given a history query with pubsub topic left empty
@@ -892,15 +950,17 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       # Then the response contains the messages
       check:
         queryResponse.get().messages == archiveMessages[0..<5]
-      
+
       # Given the next query
-      let historyQuery2 = HistoryQuery(
-        cursor: queryResponse.get().cursor,
-        pubsubTopic: none(PubsubTopic),
-        contentTopics: contentTopicSeq,
-        direction: true,
-        pageSize: 5
-      )
+      let
+        historyQuery2 =
+          HistoryQuery(
+            cursor: queryResponse.get().cursor,
+            pubsubTopic: none(PubsubTopic),
+            contentTopics: contentTopicSeq,
+            direction: PagingDirection.FORWARD,
+            pageSize: 5,
+          )
 
       # When making the next history query
       let queryResponse2 = await client.query(historyQuery2, serverRemotePeerInfo)
@@ -920,11 +980,8 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[2],
-          archiveMessages[3],
-          archiveMessages[4]
-        ]
+        queryResponse.get().messages ==
+          @[archiveMessages[2], archiveMessages[3], archiveMessages[4]]
 
     asyncTest "Only Start Time Specified":
       # Given a history query with only start time
@@ -936,12 +993,13 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[2],
-          archiveMessages[3],
-          archiveMessages[4],
-          archiveMessages[5]
-        ]
+        queryResponse.get().messages ==
+          @[
+            archiveMessages[2],
+            archiveMessages[3],
+            archiveMessages[4],
+            archiveMessages[5]
+          ]
 
     asyncTest "Only End Time Specified":
       # Given a history query with only end time
@@ -953,13 +1011,14 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains no messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[0],
-          archiveMessages[1],
-          archiveMessages[2],
-          archiveMessages[3],
-          archiveMessages[4]
-        ]
+        queryResponse.get().messages ==
+          @[
+            archiveMessages[0],
+            archiveMessages[1],
+            archiveMessages[2],
+            archiveMessages[3],
+            archiveMessages[4]
+          ]
 
     asyncTest "Invalid Time Range":
       # Given a history query with invalid time range
@@ -984,10 +1043,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[2],
-          archiveMessages[5]
-        ]
+        queryResponse.get().messages == @[archiveMessages[2], archiveMessages[5]]
 
     asyncTest "Messages Outside of Time Range":
       # Given a history query with a valid time range which does not contain any messages
@@ -1006,21 +1062,22 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
     xasyncTest "Only ephemeral Messages:":
       # Given an archive with only ephemeral messages
       let
-        ephemeralMessages = @[
-          fakeWakuMessage(@[byte 00], ts=ts(00), ephemeral=true),
-          fakeWakuMessage(@[byte 01], ts=ts(10), ephemeral=true),
-          fakeWakuMessage(@[byte 02], ts=ts(20), ephemeral=true)
-        ]
-        ephemeralArchiveDriver = newSqliteArchiveDriver(
-          ).put(
-            pubsubTopic, ephemeralMessages
-          )
-      
+        ephemeralMessages =
+          @[
+            fakeWakuMessage(@[byte 00], ts = ts(00), ephemeral = true),
+            fakeWakuMessage(@[byte 01], ts = ts(10), ephemeral = true),
+            fakeWakuMessage(@[byte 02], ts = ts(20), ephemeral = true)
+          ]
+        ephemeralArchiveDriver =
+          newSqliteArchiveDriver().put(pubsubTopic, ephemeralMessages)
+
       # And a server node with the ephemeral archive
-      let 
+      let
         ephemeralServerKey = generateSecp256k1Key()
-        ephemeralServer = newTestWakuNode(ephemeralServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
-        mountEphemeralArchiveResult = ephemeralServer.mountArchive(ephemeralArchiveDriver)
+        ephemeralServer =
+          newTestWakuNode(ephemeralServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
+        mountEphemeralArchiveResult =
+          ephemeralServer.mountArchive(ephemeralArchiveDriver)
       assert mountEphemeralArchiveResult.isOk()
 
       waitFor ephemeralServer.mountStore()
@@ -1028,7 +1085,8 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       let ephemeralServerRemotePeerInfo = ephemeralServer.peerInfo.toRemotePeerInfo()
 
       # When making a history query to the server with only ephemeral messages
-      let queryResponse = await client.query(historyQuery, ephemeralServerRemotePeerInfo)
+      let
+        queryResponse = await client.query(historyQuery, ephemeralServerRemotePeerInfo)
 
       # Then the response contains no messages
       check:
@@ -1040,27 +1098,28 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
     xasyncTest "Mixed messages":
       # Given an archive with both ephemeral and non-ephemeral messages
       let
-        ephemeralMessages = @[
-          fakeWakuMessage(@[byte 00], ts=ts(00), ephemeral=true),
-          fakeWakuMessage(@[byte 01], ts=ts(10), ephemeral=true),
-          fakeWakuMessage(@[byte 02], ts=ts(20), ephemeral=true)
-        ]
-        nonEphemeralMessages = @[
-          fakeWakuMessage(@[byte 03], ts=ts(30), ephemeral=false),
-          fakeWakuMessage(@[byte 04], ts=ts(40), ephemeral=false),
-          fakeWakuMessage(@[byte 05], ts=ts(50), ephemeral=false)
-        ]
-        mixedArchiveDriver = newSqliteArchiveDriver(
-          ).put(
-            pubsubTopic, ephemeralMessages
-          ).put(
+        ephemeralMessages =
+          @[
+            fakeWakuMessage(@[byte 00], ts = ts(00), ephemeral = true),
+            fakeWakuMessage(@[byte 01], ts = ts(10), ephemeral = true),
+            fakeWakuMessage(@[byte 02], ts = ts(20), ephemeral = true)
+          ]
+        nonEphemeralMessages =
+          @[
+            fakeWakuMessage(@[byte 03], ts = ts(30), ephemeral = false),
+            fakeWakuMessage(@[byte 04], ts = ts(40), ephemeral = false),
+            fakeWakuMessage(@[byte 05], ts = ts(50), ephemeral = false)
+          ]
+        mixedArchiveDriver =
+          newSqliteArchiveDriver().put(pubsubTopic, ephemeralMessages).put(
             pubsubTopic, nonEphemeralMessages
           )
 
       # And a server node with the mixed archive
-      let 
+      let
         mixedServerKey = generateSecp256k1Key()
-        mixedServer = newTestWakuNode(mixedServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
+        mixedServer =
+          newTestWakuNode(mixedServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
         mountMixedArchiveResult = mixedServer.mountArchive(mixedArchiveDriver)
       assert mountMixedArchiveResult.isOk()
 
@@ -1074,7 +1133,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       # Then the response contains the non-ephemeral messages
       check:
         queryResponse.get().messages == nonEphemeralMessages
-      
+
       # Cleanup
       waitFor mixedServer.stop()
 
@@ -1082,11 +1141,12 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
     asyncTest "Empty Message Store":
       # Given an empty archive
       let emptyArchiveDriver = newSqliteArchiveDriver()
-      
+
       # And a server node with the empty archive
-      let 
+      let
         emptyServerKey = generateSecp256k1Key()
-        emptyServer = newTestWakuNode(emptyServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
+        emptyServer =
+          newTestWakuNode(emptyServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
         mountEmptyArchiveResult = emptyServer.mountArchive(emptyArchiveDriver)
       assert mountEmptyArchiveResult.isOk()
 
@@ -1100,7 +1160,7 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       # Then the response contains no messages
       check:
         queryResponse.get().messages.len == 0
-      
+
       # Cleanup
       waitFor emptyServer.stop()
 
@@ -1109,14 +1169,18 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       var voluminousArchiveMessages: seq[WakuMessage] = @[]
       for i in 0..<100000:
         let topic = "topic" & $i
-        voluminousArchiveMessages.add(fakeWakuMessage(@[byte i], contentTopic=topic))
-      let voluminousArchiveDriverWithMessages = newArchiveDriverWithMessages(pubsubTopic, voluminousArchiveMessages)
+        voluminousArchiveMessages.add(fakeWakuMessage(@[byte i], contentTopic = topic))
+      let
+        voluminousArchiveDriverWithMessages =
+          newArchiveDriverWithMessages(pubsubTopic, voluminousArchiveMessages)
 
       # And a server node with the voluminous archive
-      let 
+      let
         voluminousServerKey = generateSecp256k1Key()
-        voluminousServer = newTestWakuNode(voluminousServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
-        mountVoluminousArchiveResult = voluminousServer.mountArchive(voluminousArchiveDriverWithMessages)
+        voluminousServer =
+          newTestWakuNode(voluminousServerKey, ValidIpAddress.init("0.0.0.0"), Port(0))
+        mountVoluminousArchiveResult =
+          voluminousServer.mountArchive(voluminousArchiveDriverWithMessages)
       assert mountVoluminousArchiveResult.isOk()
 
       waitFor voluminousServer.mountStore()
@@ -1124,41 +1188,37 @@ suite "Waku Store - End to End - Archive with Multiple Topics":
       let voluminousServerRemotePeerInfo = voluminousServer.peerInfo.toRemotePeerInfo()
 
       # Given the following history query
-      historyQuery.contentTopics = @[
-        "topic10000", "topic30000", "topic50000", "topic70000", "topic90000"
-      ]
+      historyQuery.contentTopics =
+        @["topic10000", "topic30000", "topic50000", "topic70000", "topic90000"]
 
       # When making a history query to the server with a voluminous archive
-      let queryResponse = await client.query(historyQuery, voluminousServerRemotePeerInfo)
+      let
+        queryResponse = await client.query(historyQuery, voluminousServerRemotePeerInfo)
 
       # Then the response contains the messages
       check:
-        queryResponse.get().messages == @[
-          voluminousArchiveMessages[10000],
-          voluminousArchiveMessages[30000],
-          voluminousArchiveMessages[50000],
-          voluminousArchiveMessages[70000],
-          voluminousArchiveMessages[90000]
-        ]
+        queryResponse.get().messages ==
+          @[
+            voluminousArchiveMessages[10000],
+            voluminousArchiveMessages[30000],
+            voluminousArchiveMessages[50000],
+            voluminousArchiveMessages[70000],
+            voluminousArchiveMessages[90000]
+          ]
 
       # Cleanup
       waitFor voluminousServer.stop()
 
     asyncTest "Large contentFilters Array":
       # Given a history query with the max contentFilters len, 10
-      historyQuery.contentTopics = @[
-        contentTopic
-      ]
+      historyQuery.contentTopics = @[contentTopic]
       for i in 0..<9:
         let topic = "topic" & $i
         historyQuery.contentTopics.add(topic)
-      
+
       # When making a history query
       let queryResponse = await client.query(historyQuery, serverRemotePeerInfo)
 
       # Then the response should trigger no errors
       check:
-        queryResponse.get().messages == @[
-          archiveMessages[0],
-          archiveMessages[3]
-        ]
+        queryResponse.get().messages == @[archiveMessages[0], archiveMessages[3]]
diff --git a/tests/resources/content_topics.nim b/tests/resources/content_topics.nim
new file mode 100644
index 000000000..0ce99ad59
--- /dev/null
+++ b/tests/resources/content_topics.nim
@@ -0,0 +1,8 @@
+proc getContentTopic*(applicationName: string, applicationVersion: int, contentTopicName: string, encoding: string): string =
+  return "/$applicationName/$applicationVersion/$contentTopicName/$enconding"
+
+
+const
+  CURRENT* = getContentTopic("application", 1, "content-topic", "proto")
+  TESTNET* = getContentTopic("toychat", 2, "huilong", "proto")
+  PLAIN* = "test"
diff --git a/tests/resources/pubsub_topics.nim b/tests/resources/pubsub_topics.nim
new file mode 100644
index 000000000..c850fb0df
--- /dev/null
+++ b/tests/resources/pubsub_topics.nim
@@ -0,0 +1,14 @@
+import std/strformat
+
+proc getPubsubTopic*(pubsubTopicName: string): string =
+  return fmt"/waku/2/{pubsubTopicName}"
+
+
+const
+  CURRENT* = getPubsubTopic("test")
+  CURRENT_NESTED* = getPubsubTopic("test/nested")
+  SHARDING* = getPubsubTopic("waku-9_shard-0")
+  PLAIN* = "test"
+  LEGACY* = "/waku/1/test"
+  LEGACY_NESTED* = "/waku/1/test/nested"
+  LEGACY_ENCODING* = "/waku/1/test/proto"
diff --git a/tests/test_waku_lightpush.nim b/tests/test_waku_lightpush.nim
deleted file mode 100644
index 76312272f..000000000
--- a/tests/test_waku_lightpush.nim
+++ /dev/null
@@ -1,154 +0,0 @@
-{.used.}
-
-import
-  std/options,
-  std/strscans,
-  testutils/unittests,
-  chronicles,
-  chronos,
-  libp2p/crypto/crypto
-import
-  ../../waku/node/peer_manager,
-  ../../waku/waku_core,
-  ../../waku/waku_lightpush,
-  ../../waku/waku_lightpush/common,
-  ../../waku/waku_lightpush/client,
-  ../../waku/waku_lightpush/protocol_metrics,
-  ../../waku/waku_lightpush/rpc,
-  ./testlib/common,
-  ./testlib/wakucore
-
-proc newTestWakuLightpushNode(switch: Switch, handler: PushMessageHandler): Future[WakuLightPush] {.async.} =
-  let
-    peerManager = PeerManager.new(switch)
-    proto = WakuLightPush.new(peerManager, rng, handler)
-
-  await proto.start()
-  switch.mount(proto)
-
-  return proto
-
-proc newTestWakuLightpushClient(switch: Switch): WakuLightPushClient =
-  let
-    peerManager = PeerManager.new(switch)
-  WakuLightPushClient.new(peerManager, rng)
-
-
-suite "Waku Lightpush":
-
-  asyncTest "push message to pubsub topic is successful":
-    ## Setup
-    let
-      serverSwitch = newTestSwitch()
-      clientSwitch = newTestSwitch()
-
-    await allFutures(serverSwitch.start(), clientSwitch.start())
-
-    ## Given
-    let handlerFuture = newFuture[(string, WakuMessage)]()
-    let handler = proc(peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage): Future[WakuLightPushResult[void]] {.async.} =
-        handlerFuture.complete((pubsubTopic, message))
-        return ok()
-
-    let
-      server = await newTestWakuLightpushNode(serverSwitch, handler)
-      client = newTestWakuLightpushClient(clientSwitch)
-
-    let serverPeerId = serverSwitch.peerInfo.toRemotePeerInfo()
-
-    let
-      topic = DefaultPubsubTopic
-      message = fakeWakuMessage()
-
-    ## When
-    let requestRes = await client.publish(topic, message, peer=serverPeerId)
-
-    require await handlerFuture.withTimeout(100.millis)
-
-    ## Then
-    check:
-      requestRes.isOk()
-      handlerFuture.finished()
-
-    let (handledMessagePubsubTopic, handledMessage) = handlerFuture.read()
-    check:
-      handledMessagePubsubTopic == topic
-      handledMessage == message
-
-    ## Cleanup
-    await allFutures(clientSwitch.stop(), serverSwitch.stop())
-
-  asyncTest "push message to pubsub topic should fail":
-    ## Setup
-    let
-      serverSwitch = newTestSwitch()
-      clientSwitch = newTestSwitch()
-
-    await allFutures(serverSwitch.start(), clientSwitch.start())
-
-    ## Given
-    let error = "test_failure"
-
-    let handlerFuture = newFuture[void]()
-    let handler = proc(peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage): Future[WakuLightPushResult[void]] {.async.} =
-        handlerFuture.complete()
-        return err(error)
-
-    let
-      server = await newTestWakuLightpushNode(serverSwitch, handler)
-      client = newTestWakuLightpushClient(clientSwitch)
-
-    let serverPeerId = serverSwitch.peerInfo.toRemotePeerInfo()
-
-    let
-      topic = DefaultPubsubTopic
-      message = fakeWakuMessage()
-
-    ## When
-    let requestRes = await client.publish(topic, message, peer=serverPeerId)
-
-    require await handlerFuture.withTimeout(100.millis)
-
-    ## Then
-    check:
-      requestRes.isErr()
-      handlerFuture.finished()
-
-    let requestError = requestRes.error
-    check:
-      requestError == error
-
-    ## Cleanup
-    await allFutures(clientSwitch.stop(), serverSwitch.stop())
-
-  asyncTest "incorrectly encoded request should return an erring response":
-    ## Setup
-    let
-      serverSwitch = newTestSwitch()
-      handler = proc(peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage): Future[WakuLightPushResult[void]] {.async.} =
-        ## this handler will never be called: request must fail earlier
-        return ok()
-      server = await newTestWakuLightpushNode(serverSwitch, handler)
-
-    ## Given
-    let
-      fakeBuffer = @[byte(42)]
-      fakePeerId = PeerId.init(PrivateKey.random(ECDSA, (newRng())[]).tryGet()).tryGet()
-    
-    ## When
-    let
-      pushRpcResponse = await server.handleRequest(fakePeerId, fakeBuffer)
-      requestId = pushRpcResponse.requestId
-    
-    ## Then
-    check:
-      requestId == ""
-      pushRpcResponse.response.isSome()
-    
-    let resp = pushRpcResponse.response.get()
-
-    check:
-      resp.isSuccess == false
-      resp.info.isSome()
-      ## the error message should start with decodeRpcFailure
-      scanf(resp.info.get(), decodeRpcFailure)
diff --git a/tests/testlib/assertions.nim b/tests/testlib/assertions.nim
new file mode 100644
index 000000000..a2f0f357e
--- /dev/null
+++ b/tests/testlib/assertions.nim
@@ -0,0 +1,4 @@
+import chronos
+
+template assertResultOk*[T, E](result: Result[T, E]) =
+  assert result.isOk(), result.error()
diff --git a/tests/testlib/futures.nim b/tests/testlib/futures.nim
index d052d29d0..d027a9c4c 100644
--- a/tests/testlib/futures.nim
+++ b/tests/testlib/futures.nim
@@ -14,3 +14,23 @@ proc newBoolFuture*(): Future[bool] =
 
 proc newHistoryFuture*(): Future[HistoryQuery] =
   newFuture[HistoryQuery]()
+
+proc toResult*[T](future: Future[T]): Result[T, string] =
+  if future.cancelled():
+    return chronos.err("Future timeouted before completing.")
+  elif future.finished() and not future.failed():
+    return chronos.ok(future.read())
+  else:
+    return chronos.err("Future finished but failed.")
+
+proc toResult*(future: Future[void]): Result[void, string] =
+  if future.cancelled():
+    return chronos.err("Future timeouted before completing.")
+  elif future.finished() and not future.failed():
+    return chronos.ok()
+  else:
+    return chronos.err("Future finished but failed.")
+
+proc waitForResult*[T](future: Future[T], timeout = FUTURE_TIMEOUT): Future[Result[T, string]] {.async.} =
+  discard await future.withTimeout(timeout)
+  return future.toResult()
diff --git a/tests/waku_archive/archive_utils.nim b/tests/waku_archive/archive_utils.nim
index aab349847..a4daee55d 100644
--- a/tests/waku_archive/archive_utils.nim
+++ b/tests/waku_archive/archive_utils.nim
@@ -1,9 +1,6 @@
 {.used.}
 
-import
-  std/options,
-  chronos,
-  libp2p/crypto/crypto
+import std/options, stew/results, chronos, libp2p/crypto/crypto
 
 import
   ../../../waku/[
@@ -14,43 +11,42 @@ import
     waku_archive/driver/sqlite_driver,
     common/databases/db_sqlite
   ],
-  ../testlib/[
-    wakucore
-  ]
-
+  ../testlib/[wakucore]
 
 proc newSqliteDatabase*(): SqliteDatabase =
   SqliteDatabase.new(":memory:").tryGet()
 
-
 proc newSqliteArchiveDriver*(): ArchiveDriver =
   let database = newSqliteDatabase()
   SqliteDriver.new(database).tryGet()
 
-
 proc newWakuArchive*(driver: ArchiveDriver): WakuArchive =
   WakuArchive.new(driver).get()
 
-
-proc computeArchiveCursor*(pubsubTopic: PubsubTopic, message: WakuMessage): ArchiveCursor =
+proc computeArchiveCursor*(
+    pubsubTopic: PubsubTopic, message: WakuMessage
+): ArchiveCursor =
   ArchiveCursor(
     pubsubTopic: pubsubTopic,
     senderTime: message.timestamp,
     storeTime: message.timestamp,
-    digest: waku_archive.computeDigest(message)
+    digest: waku_archive.computeDigest(message),
   )
 
-
-proc put*(driver: ArchiveDriver, pubsubTopic: PubSubTopic, msgList: seq[WakuMessage]): ArchiveDriver =
+proc put*(
+    driver: ArchiveDriver, pubsubTopic: PubSubTopic, msgList: seq[WakuMessage]
+): ArchiveDriver =
   for msg in msgList:
-    let 
+    let
       msgDigest = waku_archive.computeDigest(msg)
       msgHash = computeMessageHash(pubsubTopic, msg)
-    discard waitFor driver.put(pubsubTopic, msg, msgDigest, msgHash, msg.timestamp)
+      _ = waitFor driver.put(pubsubTopic, msg, msgDigest, msgHash, msg.timestamp)
+          # discard crashes
   return driver
 
-
-proc newArchiveDriverWithMessages*(pubsubTopic: PubSubTopic, msgList: seq[WakuMessage]): ArchiveDriver = 
+proc newArchiveDriverWithMessages*(
+    pubsubTopic: PubSubTopic, msgList: seq[WakuMessage]
+): ArchiveDriver =
   var driver = newSqliteArchiveDriver()
   driver = driver.put(pubsubTopic, msgList)
   return driver
diff --git a/tests/waku_lightpush/lightpush_utils.nim b/tests/waku_lightpush/lightpush_utils.nim
new file mode 100644
index 000000000..3ee4af89a
--- /dev/null
+++ b/tests/waku_lightpush/lightpush_utils.nim
@@ -0,0 +1,33 @@
+{.used.}
+
+import
+  std/options,
+  chronicles,
+  chronos,
+  libp2p/crypto/crypto
+
+import
+  ../../waku/node/peer_manager,
+  ../../waku/waku_core,
+  ../../waku/waku_lightpush,
+  ../../waku/waku_lightpush/[client, common],
+  ../testlib/[
+    common, 
+    wakucore
+  ]
+
+
+proc newTestWakuLightpushNode*(switch: Switch, handler: PushMessageHandler): Future[WakuLightPush] {.async.} =
+  let
+    peerManager = PeerManager.new(switch)
+    proto = WakuLightPush.new(peerManager, rng, handler)
+
+  await proto.start()
+  switch.mount(proto)
+
+  return proto
+
+
+proc newTestWakuLightpushClient*(switch: Switch): WakuLightPushClient =
+  let peerManager = PeerManager.new(switch)
+  WakuLightPushClient.new(peerManager, rng)
diff --git a/tests/waku_lightpush/test_all.nim b/tests/waku_lightpush/test_all.nim
new file mode 100644
index 000000000..805f6df19
--- /dev/null
+++ b/tests/waku_lightpush/test_all.nim
@@ -0,0 +1,2 @@
+import
+  ./test_client
diff --git a/tests/waku_lightpush/test_client.nim b/tests/waku_lightpush/test_client.nim
new file mode 100644
index 000000000..de5e1b762
--- /dev/null
+++ b/tests/waku_lightpush/test_client.nim
@@ -0,0 +1,362 @@
+{.used.}
+
+import
+  std/[options, strscans],
+  testutils/unittests,
+  chronicles,
+  chronos,
+  libp2p/crypto/crypto
+
+import
+  ../../../waku/[
+    node/peer_manager,
+    waku_core,
+    waku_lightpush,
+    waku_lightpush/client,
+    waku_lightpush/common,
+    waku_lightpush/protocol_metrics,
+    waku_lightpush/rpc,
+    waku_lightpush/rpc_codec
+  ],
+  ../testlib/[assertions, wakucore, testasync, futures, testutils],
+  ./lightpush_utils,
+  ../resources/[pubsub_topics, content_topics, payloads]
+
+suite "Waku Lightpush Client":
+  var
+    handlerFuture {.threadvar.}: Future[(PubsubTopic, WakuMessage)]
+    handler {.threadvar.}: PushMessageHandler
+
+    serverSwitch {.threadvar.}: Switch
+    clientSwitch {.threadvar.}: Switch
+    server {.threadvar.}: WakuLightPush
+    client {.threadvar.}: WakuLightPushClient
+
+    serverRemotePeerInfo {.threadvar.}: RemotePeerInfo
+    clientPeerId {.threadvar.}: PeerId
+    pubsubTopic {.threadvar.}: PubsubTopic
+    contentTopic {.threadvar.}: ContentTopic
+    message {.threadvar.}: WakuMessage
+
+  asyncSetup:
+    handlerFuture = newPushHandlerFuture()
+    handler =
+      proc(
+        peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage
+      ): Future[WakuLightPushResult[void]] {.async.} =
+          handlerFuture.complete((pubsubTopic, message))
+          return ok()
+
+    serverSwitch = newTestSwitch()
+    clientSwitch = newTestSwitch()
+    server = await newTestWakuLightpushNode(serverSwitch, handler)
+    client = newTestWakuLightpushClient(clientSwitch)
+
+    await allFutures(serverSwitch.start(), clientSwitch.start())
+
+    serverRemotePeerInfo = serverSwitch.peerInfo.toRemotePeerInfo()
+    clientPeerId = clientSwitch.peerInfo.peerId
+    pubsubTopic = DefaultPubsubTopic
+    contentTopic = DefaultContentTopic
+    message = fakeWakuMessage()
+
+  asyncTeardown:
+    await allFutures(clientSwitch.stop(), serverSwitch.stop())
+
+  suite "Verification of PushRequest Payload":
+    asyncTest "Valid Payload Types":
+      # Given the following payloads
+      let
+        message2 = fakeWakuMessage(payloads.ALPHABETIC, content_topics.CURRENT)
+        message3 = fakeWakuMessage(payloads.ALPHANUMERIC, content_topics.TESTNET)
+        message4 = fakeWakuMessage(payloads.ALPHANUMERIC_SPECIAL, content_topics.PLAIN)
+        message5 = fakeWakuMessage(payloads.EMOJI, content_topics.CURRENT)
+        message6 = fakeWakuMessage(payloads.CODE, content_topics.TESTNET)
+        message7 = fakeWakuMessage(payloads.QUERY, content_topics.PLAIN)
+        message8 = fakeWakuMessage(payloads.TEXT_SMALL, content_topics.CURRENT)
+        message9 = fakeWakuMessage(payloads.TEXT_LARGE, content_topics.TESTNET)
+
+      # When publishing a valid payload
+      let
+        publishResponse =
+          await client.publish(pubsubTopic, message, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsubTopic, message) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse2 =
+          await client.publish(pubsub_topics.CURRENT, message2, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse2
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.CURRENT, message2) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse3 =
+          await client.publish(
+            pubsub_topics.CURRENT_NESTED, message3, serverRemotePeerInfo
+          )
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse3
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.CURRENT_NESTED, message3) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse4 =
+          await client.publish(pubsub_topics.SHARDING, message4, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse4
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.SHARDING, message4) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse5 =
+          await client.publish(pubsub_topics.PLAIN, message5, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse5
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.PLAIN, message5) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse6 =
+          await client.publish(pubsub_topics.LEGACY, message6, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse6
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.LEGACY, message6) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse7 =
+          await client.publish(
+            pubsub_topics.LEGACY_NESTED, message7, serverRemotePeerInfo
+          )
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse7
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.LEGACY_NESTED, message7) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse8 =
+          await client.publish(
+            pubsub_topics.LEGACY_ENCODING, message8, serverRemotePeerInfo
+          )
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse8
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsub_topics.LEGACY_ENCODING, message8) == handlerFuture.read()
+
+      # When publishing a valid payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse9 =
+          await client.publish(pubsubTopic, message9, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      discard await handlerFuture.withTimeout(FUTURE_TIMEOUT)
+      assertResultOk publishResponse9
+      check handlerFuture.finished()
+
+      # And the message is received with the correct topic and payload
+      check (pubsubTopic, message9) == handlerFuture.read()
+
+    asyncTest "Valid Payload Sizes":
+      # Given some valid payloads
+      let
+        overheadBytes: uint64 = 112
+        message1 =
+          fakeWakuMessage(contentTopic = contentTopic, payload = getByteSequence(1024))
+          # 1KiB
+        message2 =
+          fakeWakuMessage(
+            contentTopic = contentTopic, payload = getByteSequence(10 * 1024)
+          ) # 10KiB 
+        message3 =
+          fakeWakuMessage(
+            contentTopic = contentTopic, payload = getByteSequence(100 * 1024)
+          ) # 100KiB
+        message4 =
+          fakeWakuMessage(
+            contentTopic = contentTopic,
+            payload = getByteSequence(MaxRpcSize - overheadBytes - 1),
+          ) # Inclusive Limit
+        message5 =
+          fakeWakuMessage(
+            contentTopic = contentTopic,
+            payload = getByteSequence(MaxRpcSize - overheadBytes),
+          ) # Exclusive Limit
+
+      # When publishing the 1KiB payload
+      let
+        publishResponse1 =
+          await client.publish(pubsubTopic, message1, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      assertResultOk publishResponse1
+      check (pubsubTopic, message1) == (await handlerFuture.waitForResult()).value()
+
+      # When publishing the 10KiB payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse2 =
+          await client.publish(pubsubTopic, message2, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      assertResultOk publishResponse2
+      check (pubsubTopic, message2) == (await handlerFuture.waitForResult()).value()
+
+      # When publishing the 100KiB payload
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse3 =
+          await client.publish(pubsubTopic, message3, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      assertResultOk publishResponse3
+      check (pubsubTopic, message3) == (await handlerFuture.waitForResult()).value()
+
+      # When publishing the 1MiB + 63KiB + 911B payload (1113999B)
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse4 =
+          await client.publish(pubsubTopic, message4, serverRemotePeerInfo)
+
+      # Then the message is received by the server
+      assertResultOk publishResponse4
+      check (pubsubTopic, message4) == (await handlerFuture.waitForResult()).value()
+
+      # When publishing the 1MiB + 63KiB + 912B payload (1114000B)
+      handlerFuture = newPushHandlerFuture()
+      let
+        publishResponse5 =
+          await client.publish(pubsubTopic, message5, serverRemotePeerInfo)
+
+      # Then the message is not received by the server
+      check:
+        not publishResponse5.isOk()
+        (await handlerFuture.waitForResult()).isErr()
+
+    asyncTest "Invalid Encoding Payload":
+      # Given a payload with an invalid encoding
+      let fakeBuffer = @[byte(42)]
+
+      # When publishing the payload
+      let publishResponse = await server.handleRequest(clientPeerId, fakeBuffer)
+
+      # Then the response is negative
+      check:
+        publishResponse.requestId == ""
+
+      # And the error is returned
+      let response = publishResponse.response.get()
+      check:
+        response.isSuccess == false
+        response.info.isSome()
+        scanf(response.info.get(), decodeRpcFailure)
+
+    asyncTest "Handle Error":
+      # Given a lightpush server that fails
+      let
+        handlerError = "handler-error"
+        handlerFuture2 = newFuture[void]()
+        handler2 =
+          proc(
+            peer: PeerId, pubsubTopic: PubsubTopic, message: WakuMessage
+          ): Future[WakuLightPushResult[void]] {.async.} =
+              handlerFuture2.complete()
+              return err(handlerError)
+
+      let
+        serverSwitch2 = newTestSwitch()
+        server2 = await newTestWakuLightpushNode(serverSwitch2, handler2)
+
+      await serverSwitch2.start()
+
+      let serverRemotePeerInfo2 = serverSwitch2.peerInfo.toRemotePeerInfo()
+
+      # When publishing a payload
+      let
+        publishResponse =
+          await client.publish(pubsubTopic, message, serverRemotePeerInfo2)
+
+      # Then the response is negative
+      check:
+        publishResponse.error() == handlerError
+        (await handlerFuture2.waitForResult()).isOk()
+
+      # Cleanup
+      await serverSwitch2.stop()
+
+  suite "Verification of PushResponse Payload":
+    asyncTest "Positive Responses":
+      # When sending a valid PushRequest
+      let
+        publishResponse =
+          await client.publish(pubsubTopic, message, serverRemotePeerInfo)
+
+      # Then the response is positive
+      assertResultOk publishResponse
+
+    # TODO: Improve: Add more negative responses variations
+    asyncTest "Negative Responses":
+      # Given a server that does not support Waku Lightpush
+      let
+        serverSwitch2 = newTestSwitch()
+        serverRemotePeerInfo2 = serverSwitch2.peerInfo.toRemotePeerInfo()
+
+      await serverSwitch2.start()
+
+      # When sending an invalid PushRequest
+      let
+        publishResponse =
+          await client.publish(pubsubTopic, message, serverRemotePeerInfo2)
+
+      # Then the response is negative
+      check not publishResponse.isOk()
diff --git a/tests/waku_store/test_all.nim b/tests/waku_store/test_all.nim
index e74805c39..b495310f2 100644
--- a/tests/waku_store/test_all.nim
+++ b/tests/waku_store/test_all.nim
@@ -1,6 +1,7 @@
 {.used.}
 
 import
+  ./test_client,
   ./test_resume,
   ./test_rpc_codec,
   ./test_waku_store,
diff --git a/tests/waku_store/test_client.nim b/tests/waku_store/test_client.nim
index 120678b9f..b8386dfeb 100644
--- a/tests/waku_store/test_client.nim
+++ b/tests/waku_store/test_client.nim
@@ -14,6 +14,7 @@ import
     waku_core,
     waku_store,
     waku_store/client,
+    common/paging
   ],
   ../testlib/[
     common,
@@ -55,7 +56,7 @@ suite "Store Client":
     historyQuery = HistoryQuery(
       pubsubTopic: some(DefaultPubsubTopic),
       contentTopics: @[DefaultContentTopic],
-      ascending: true
+      direction: PagingDirection.FORWARD
     )
 
     serverSwitch = newTestSwitch()
@@ -93,12 +94,12 @@ suite "Store Client":
         invalidQuery1 = HistoryQuery(
           pubsubTopic: some(DefaultPubsubTopic),
           contentTopics: @[],
-          ascending: true
+          direction: PagingDirection.FORWARD
         )
         invalidQuery2 = HistoryQuery(
           pubsubTopic: PubsubTopic.none(),
           contentTopics: @[DefaultContentTopic],
-          ascending: true
+          direction: PagingDirection.FORWARD
         )
         invalidQuery3 = HistoryQuery(
           pubsubTopic: some(DefaultPubsubTopic),
diff --git a/vendor/nim-unittest2 b/vendor/nim-unittest2
index 262b697f3..db67e2ad7 160000
--- a/vendor/nim-unittest2
+++ b/vendor/nim-unittest2
@@ -1 +1 @@
-Subproject commit 262b697f38d6b6f1e7462d3b3ab81d79b894e336
+Subproject commit db67e2ad76840993ff82015987e3089a7d76f55f
diff --git a/waku/waku_lightpush/client.nim b/waku/waku_lightpush/client.nim
index 9cda80e24..5dd23a988 100644
--- a/waku/waku_lightpush/client.nim
+++ b/waku/waku_lightpush/client.nim
@@ -45,7 +45,12 @@ proc sendPushRequest(wl: WakuLightPushClient, req: PushRequest, peer: PeerId|Rem
   let rpc = PushRPC(requestId: generateRequestId(wl.rng), request: some(req))
   await connection.writeLP(rpc.encode().buffer)
 
-  var buffer = await connection.readLp(MaxRpcSize.int)
+  var buffer: seq[byte]
+  try:
+    buffer = await connection.readLp(MaxRpcSize.int)
+  except LPStreamRemoteClosedError:
+    return err("Exception reading: " & getCurrentExceptionMsg())
+
   let decodeRespRes = PushRPC.decode(buffer)
   if decodeRespRes.isErr():
     error "failed to decode response"