diff --git a/apps/chat2/chat2.nim b/apps/chat2/chat2.nim
index 828e7fbbd..877c7044e 100644
--- a/apps/chat2/chat2.nim
+++ b/apps/chat2/chat2.nim
@@ -468,6 +468,7 @@ proc processInput(rfd: AsyncFD, rng: ref HmacDrbgContext) {.async.} =
     let peerInfo = parsePeerInfo(conf.filternode)
     if peerInfo.isOk():
       await node.mountFilter()
+      await node.mountLegacyFilter()
       await node.mountFilterClient()
       node.peerManager.addServicePeer(peerInfo.value, WakuLegacyFilterCodec)
 
@@ -507,7 +508,7 @@ proc processInput(rfd: AsyncFD, rng: ref HmacDrbgContext) {.async.} =
           echo "A spam message is found and discarded"
         chat.prompt = false
         showChatPrompt(chat)
-    
+
       echo "rln-relay preparation is in progress..."
 
       let rlnConf = WakuRlnConfig(
diff --git a/apps/chat2bridge/chat2bridge.nim b/apps/chat2bridge/chat2bridge.nim
index 106eaf7e5..375f6c196 100644
--- a/apps/chat2bridge/chat2bridge.nim
+++ b/apps/chat2bridge/chat2bridge.nim
@@ -288,6 +288,7 @@ when isMainModule:
 
   if conf.filter:
     waitFor mountFilter(bridge.nodev2)
+    waitFor mountLegacyFilter(bridge.nodev2)
 
   if conf.staticnodes.len > 0:
     waitFor connectToNodes(bridge.nodev2, conf.staticnodes)
diff --git a/apps/wakunode2/app.nim b/apps/wakunode2/app.nim
index e724f17a9..0863eefe6 100644
--- a/apps/wakunode2/app.nim
+++ b/apps/wakunode2/app.nim
@@ -254,7 +254,7 @@ proc setupDiscoveryV5*(app: App): WakuDiscoveryV5 =
   )
 
   WakuDiscoveryV5.new(
-    app.rng, 
+    app.rng,
     discv5Conf,
     some(app.record),
     some(app.node.peerManager),
@@ -326,7 +326,7 @@ proc setupWakuApp*(app: var App): AppResult[void] =
   ok()
 
 proc getPorts(listenAddrs: seq[MultiAddress]):
-              AppResult[tuple[tcpPort, websocketPort: Option[Port]]] = 
+              AppResult[tuple[tcpPort, websocketPort: Option[Port]]] =
 
   var tcpPort, websocketPort = none(Port)
 
@@ -548,7 +548,15 @@ proc setupProtocols(node: WakuNode,
   # Filter setup. NOTE Must be mounted after relay
   if conf.filter:
     try:
-      await mountFilter(node, filterTimeout = chronos.seconds(conf.filterTimeout))
+      await mountLegacyFilter(node, filterTimeout = chronos.seconds(conf.filterTimeout))
+    except CatchableError:
+      return err("failed to mount waku legacy filter protocol: " & getCurrentExceptionMsg())
+
+    try:
+      await mountFilter(node,
+                        subscriptionTimeout = chronos.seconds(conf.filterSubscriptionTimeout),
+                        maxFilterPeers = conf.filterMaxPeersToServe,
+                        maxFilterCriteriaPerPeer = conf.filterMaxCriteria)
     except CatchableError:
       return err("failed to mount waku filter protocol: " & getCurrentExceptionMsg())
 
@@ -724,7 +732,7 @@ proc startRestServer(app: App, address: IpAddress, port: Port, conf: WakuNodeCon
 
     let filterCache = MessageCache.init()
 
-    let filterDiscoHandler = 
+    let filterDiscoHandler =
       if app.wakuDiscv5.isSome():
         some(defaultDiscoveryHandler(app.wakuDiscv5.get(), Filter))
       else: none(DiscoveryHandler)
@@ -739,7 +747,7 @@ proc startRestServer(app: App, address: IpAddress, port: Port, conf: WakuNodeCon
     notInstalledTab["filter"] = "/filter endpoints are not available. Please check your configuration: --filternode"
 
   ## Store REST API
-  let storeDiscoHandler = 
+  let storeDiscoHandler =
     if app.wakuDiscv5.isSome():
       some(defaultDiscoveryHandler(app.wakuDiscv5.get(), Store))
     else: none(DiscoveryHandler)
@@ -749,7 +757,7 @@ proc startRestServer(app: App, address: IpAddress, port: Port, conf: WakuNodeCon
   ## Light push API
   if conf.lightpushnode  != "" and
      app.node.wakuLightpushClient != nil:
-    let lightDiscoHandler = 
+    let lightDiscoHandler =
       if app.wakuDiscv5.isSome():
         some(defaultDiscoveryHandler(app.wakuDiscv5.get(), Lightpush))
       else: none(DiscoveryHandler)
diff --git a/apps/wakunode2/external_config.nim b/apps/wakunode2/external_config.nim
index 111c622e9..22235af69 100644
--- a/apps/wakunode2/external_config.nim
+++ b/apps/wakunode2/external_config.nim
@@ -95,6 +95,7 @@ type
         defaultValue: false,
         name: "execute" .}: bool
 
+
     of noCommand:
       ##  Application-level configuration
       protectedTopics* {.
@@ -221,7 +222,7 @@ type
         desc: "Rln relay identity commitment key as a Hex string",
         defaultValue: ""
         name: "rln-relay-id-commitment-key" }: string
-      
+
       rlnRelayTreePath* {.
         desc: "Path to the RLN merkle tree sled db (https://github.com/spacejam/sled)",
         defaultValue: ""
@@ -304,10 +305,25 @@ type
         name: "filternode" }: string
 
       filterTimeout* {.
-        desc: "Timeout for filter node in seconds.",
+        desc: "Filter clients will be wiped out if not able to receive push messages within this timeout. In seconds.",
         defaultValue: 14400 # 4 hours
         name: "filter-timeout" }: int64
 
+      filterSubscriptionTimeout* {.
+        desc: "Timeout for filter subscription without ping or refresh it, in seconds. Only for v2 filter protocol.",
+        defaultValue: 300 # 5 minutes
+        name: "filter-subscription-timeout" }: int64
+
+      filterMaxPeersToServe* {.
+        desc: "Maximum number of peers to serve at a time. Only for v2 filter protocol.",
+        defaultValue: 1000
+        name: "filter-max-peers-to-serve" }: uint32
+
+      filterMaxCriteria* {.
+        desc: "Maximum number of pubsub- and content topic combination per peers at a time. Only for v2 filter protocol.",
+        defaultValue: 1000
+        name: "filter-max-criteria" }: uint32
+
       ## Lightpush config
 
       lightpush* {.
diff --git a/tests/node/test_wakunode_filter.nim b/tests/node/test_wakunode_filter.nim
index 7b7024b54..d486eb180 100644
--- a/tests/node/test_wakunode_filter.nim
+++ b/tests/node/test_wakunode_filter.nim
@@ -1,9 +1,9 @@
-{.used.}  
+{.used.}
 
 import
   std/[
-    options, 
-    tables, 
+    options,
+    tables,
     sequtils
   ],
   stew/shims/net as stewNet,
@@ -12,7 +12,7 @@ import
   chronicles,
   os,
   libp2p/[
-    peerstore, 
+    peerstore,
     crypto/crypto
   ]
 
@@ -44,7 +44,7 @@ suite "Waku Filter - End to End":
   var contentTopicSeq {.threadvar.}: seq[ContentTopic]
   var pushHandlerFuture {.threadvar.}: Future[(string, WakuMessage)]
   var messagePushHandler {.threadvar.}: FilterPushHandler
-  
+
   asyncSetup:
     pushHandlerFuture = newFuture[(string, WakuMessage)]()
     messagePushHandler = proc(
@@ -84,8 +84,8 @@ suite "Waku Filter - End to End":
     # Then the subscription is successful
     check:
       subscribeResponse.isOk()
-      server.wakuFilter.subscriptions.len == 1
-      server.wakuFilter.subscriptions.hasKey(clientPeerId)
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 1
+      server.wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
     # When sending a message to the subscribed content topic
     let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -106,7 +106,7 @@ suite "Waku Filter - End to End":
     # Then the unsubscription is successful
     check:
       unsubscribeResponse.isOk()
-      server.wakuFilter.subscriptions.len == 0
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 0
 
     # When sending a message to the previously subscribed content topic
     pushHandlerFuture = newPushHandlerFuture() # Clear previous future
@@ -116,7 +116,7 @@ suite "Waku Filter - End to End":
     # Then the message is not pushed to the client
     check:
       not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
-  
+
   asyncTest "Client Node can't receive Push from Server Node, via Relay":
     # Given the server node has Relay enabled
     await server.mountRelay()
@@ -127,7 +127,7 @@ suite "Waku Filter - End to End":
     )
     require:
       subscribeResponse.isOk()
-      server.wakuFilter.subscriptions.len == 1
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 1
 
     # When a server node gets a Relay message
     let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -141,7 +141,7 @@ suite "Waku Filter - End to End":
     let
       serverKey = generateSecp256k1Key()
       server = newTestWakuNode(serverKey, parseIpAddress("0.0.0.0"), Port(0))
-    
+
     waitFor server.start()
     waitFor server.mountRelay()
 
@@ -162,8 +162,8 @@ suite "Waku Filter - End to End":
     )
     require:
       subscribeResponse.isOk()
-      server.wakuFilter.subscriptions.len == 1
-    
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 1
+
     # And the client node reboots
     waitFor client.stop()
     waitFor client.start()
@@ -189,8 +189,8 @@ suite "Waku Filter - End to End":
     )
     require:
       subscribeResponse.isOk()
-      server.wakuFilter.subscriptions.len == 1
-      
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 1
+
     # And the client node reboots
     waitFor client.stop()
     waitFor client.start()
@@ -209,7 +209,7 @@ suite "Waku Filter - End to End":
     )
     check:
       subscribeResponse2.isOk()
-      server.wakuFilter.subscriptions.len == 1
+      server.wakuFilter.subscriptions.subscribedPeerCount() == 1
 
     # When a message is sent to the subscribed content topic, via Relay
     pushHandlerFuture = newPushHandlerFuture()
diff --git a/tests/test_peer_manager.nim b/tests/test_peer_manager.nim
index 8576f2725..25f4a9e77 100644
--- a/tests/test_peer_manager.nim
+++ b/tests/test_peer_manager.nim
@@ -53,6 +53,7 @@ procSuite "Peer Manager":
     await allFutures(nodes.mapIt(it.start()))
     await allFutures(nodes.mapIt(it.mountRelay()))
     await allFutures(nodes.mapIt(it.mountFilter()))
+    await allFutures(nodes.mapIt(it.mountLegacyFilter()))
 
     # Dial node2 from node1
     let conn = await nodes[0].peerManager.dialPeer(nodes[1].peerInfo.toRemotePeerInfo(), WakuLegacyFilterCodec)
@@ -528,6 +529,7 @@ procSuite "Peer Manager":
     await allFutures(nodes.mapIt(it.start()))
     await allFutures(nodes.mapIt(it.mountRelay()))
     await allFutures(nodes.mapIt(it.mountFilter()))
+    await allFutures(nodes.mapIt(it.mountLegacyFilter()))
 
     let pInfos = nodes.mapIt(it.switch.peerInfo.toRemotePeerInfo())
 
@@ -579,6 +581,7 @@ procSuite "Peer Manager":
     await allFutures(nodes.mapIt(it.start()))
     await allFutures(nodes.mapIt(it.mountRelay()))
     await allFutures(nodes.mapIt(it.mountFilter()))
+    await allFutures(nodes.mapIt(it.mountLegacyFilter()))
 
     let pInfos = nodes.mapIt(it.switch.peerInfo.toRemotePeerInfo())
 
diff --git a/tests/test_wakunode_filter_legacy.nim b/tests/test_wakunode_filter_legacy.nim
index cf0e37bc9..85b8c37db 100644
--- a/tests/test_wakunode_filter_legacy.nim
+++ b/tests/test_wakunode_filter_legacy.nim
@@ -29,6 +29,7 @@ suite "WakuNode - Filter":
     waitFor allFutures(server.start(), client.start())
 
     waitFor server.mountFilter()
+    waitFor server.mountLegacyFilter()
     waitFor client.mountFilterClient()
 
     ## Given
diff --git a/tests/waku_filter_v2/test_waku_client.nim b/tests/waku_filter_v2/test_waku_client.nim
index 3d4d489f3..b0f2a653f 100644
--- a/tests/waku_filter_v2/test_waku_client.nim
+++ b/tests/waku_filter_v2/test_waku_client.nim
@@ -2,10 +2,10 @@
 
 import
   std/[
-    options, 
-    tables, 
-    sequtils, 
-    strutils, 
+    options,
+    tables,
+    sequtils,
+    strutils,
     json
   ],
   testutils/unittests,
@@ -40,7 +40,6 @@ import
   ./waku_filter_utils,
   ../resources/payloads
 
-
 suite "Waku Filter - End to End":
   suite "MessagePushHandler - Void":
     var serverSwitch {.threadvar.}: Switch
@@ -77,27 +76,26 @@ suite "Waku Filter - End to End":
       wakuFilterClient.registerPushHandler(messagePushHandler)
       serverRemotePeerInfo = serverSwitch.peerInfo.toRemotePeerInfo()
       clientPeerId = clientSwitch.peerInfo.toRemotePeerInfo().peerId
-      
+
     asyncTeardown:
       await allFutures(wakuFilter.stop(), wakuFilterClient.stop(), serverSwitch.stop(), clientSwitch.stop())
 
     suite "Subscriber Ping":
       asyncTest "Active Subscription Identification":
         # Given
-        let 
+        let
           subscribeResponse = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, contentTopicSeq
           )
         assert subscribeResponse.isOk(), $subscribeResponse.error
-        check wakuFilter.subscriptions.hasKey(clientPeerId)
+        check wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When
         let subscribedPingResponse = await wakuFilterClient.ping(serverRemotePeerInfo)
-
         # Then
         assert subscribedPingResponse.isOk(), $subscribedPingResponse.error
         check:
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
       asyncTest "No Active Subscription Identification":
         # When
@@ -107,26 +105,24 @@ suite "Waku Filter - End to End":
         check:
           unsubscribedPingResponse.isErr() # Not subscribed
           unsubscribedPingResponse.error().kind == FilterSubscribeErrorKind.NOT_FOUND
-
       asyncTest "After Unsubscription":
         # Given
-        let 
+        let
           subscribeResponse = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, contentTopicSeq
           )
 
         assert subscribeResponse.isOk(), $subscribeResponse.error
-        check wakuFilter.subscriptions.hasKey(clientPeerId)
+        check wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
         )
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
-        check not wakuFilter.subscriptions.hasKey(clientPeerId)
+        check not wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         let unsubscribedPingResponse = await wakuFilterClient.ping(serverRemotePeerInfo)
-
         # Then
         check:
           unsubscribedPingResponse.isErr() # Not subscribed
@@ -171,9 +167,9 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When sending a message to the subscribed content topic
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -185,7 +181,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic == pubsubTopic
           pushedMsg == msg1
-        
+
         # When sending a message to a non-subscribed content topic (before unsubscription)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg2 = fakeWakuMessage(contentTopic=nonExistentContentTopic)
@@ -201,7 +197,7 @@ suite "Waku Filter - End to End":
         )
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
         # When sending a message to the previously unsubscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
@@ -211,7 +207,7 @@ suite "Waku Filter - End to End":
         # Then the message is not pushed to the client
         check:
           not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
-        
+
         # When sending a message to a non-subscribed content topic (after unsubscription)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg4 = fakeWakuMessage(contentTopic=nonExistentContentTopic)
@@ -233,9 +229,9 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicsSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicsSeq)
 
         # When sending a message to the one of the subscribed content topics
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -247,7 +243,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic1 == pubsubTopic
           pushedMsg1 == msg1
-        
+
         # When sending a message to the other subscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg2 = fakeWakuMessage(contentTopic=otherContentTopic)
@@ -259,7 +255,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic2 == pubsubTopic
           pushedMsg2 == msg2
-        
+
         # When sending a message to a non-subscribed content topic (before unsubscription)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg3 = fakeWakuMessage(contentTopic=nonExistentContentTopic)
@@ -268,14 +264,14 @@ suite "Waku Filter - End to End":
         # Then the message is not pushed to the client
         check:
           not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
-        
+
         # Given a valid unsubscription to an existing subscription
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicsSeq
         )
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
-        check wakuFilter.subscriptions.len == 0
-        
+        check wakuFilter.subscriptions.subscribedPeerCount() == 0
+
         # When sending a message to the previously unsubscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg4 = fakeWakuMessage(contentTopic=contentTopic)
@@ -293,7 +289,7 @@ suite "Waku Filter - End to End":
         # Then the message is not pushed to the client
         check:
           not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
-        
+
         # When sending a message to a non-subscribed content topic (after unsubscription)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg6 = fakeWakuMessage(contentTopic=nonExistentContentTopic)
@@ -311,15 +307,15 @@ suite "Waku Filter - End to End":
 
         # When subscribing to a pubsub topic
         let subscribeResponse1 = await wakuFilterClient.subscribe(
-          serverRemotePeerInfo, pubsubTopic, contentTopicSeq 
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
         )
 
         # Then the subscription is successful
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When subscribing to a different pubsub topic
         let subscribeResponse2 = await wakuFilterClient.subscribe(
@@ -329,9 +325,9 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq & otherContentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq & otherContentTopicSeq)
 
         # When sending a message to one of the subscribed content topics
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -343,7 +339,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic1 == pubsubTopic
           pushedMsg1 == msg1
-        
+
         # When sending a message to the other subscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg2 = fakeWakuMessage(contentTopic=otherContentTopic)
@@ -373,10 +369,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == otherContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), otherContentTopicSeq)
+
         # When sending a message to the previously subscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg4 = fakeWakuMessage(contentTopic=contentTopic)
@@ -385,7 +381,7 @@ suite "Waku Filter - End to End":
         # Then the message is not pushed to the client
         check:
           not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
-        
+
         # When sending a message to the still subscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg5 = fakeWakuMessage(contentTopic=otherContentTopic)
@@ -397,7 +393,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic3 == otherPubsubTopic
           pushedMsg3 == msg5
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, otherPubsubTopic, otherContentTopicSeq
@@ -406,7 +402,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
         # When sending a message to the previously unsubscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
@@ -431,9 +427,9 @@ suite "Waku Filter - End to End":
         # Then
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When subscribing to a different content topic
         let subscribeResponse2 = await wakuFilterClient.subscribe(
@@ -443,9 +439,9 @@ suite "Waku Filter - End to End":
         # Then
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq & otherContentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq & otherContentTopicSeq)
 
         # When sending a message to one of the subscribed content topics
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -457,7 +453,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic1 == pubsubTopic
           pushedMsg1 == msg1
-        
+
         # When sending a message to the other subscribed content topic
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg2 = fakeWakuMessage(contentTopic=otherContentTopic)
@@ -485,8 +481,8 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
+
         # When sending a message the previously subscribed content topics
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg4 = fakeWakuMessage(contentTopic=contentTopic)
@@ -508,15 +504,15 @@ suite "Waku Filter - End to End":
 
         # When subscribing to a pubsub topic
         let subscribeResponse1 = await wakuFilterClient.subscribe(
-          serverRemotePeerInfo, pubsubTopic, contentTopicsSeq1 
+          serverRemotePeerInfo, pubsubTopic, contentTopicsSeq1
         )
 
         # Then the subscription is successful
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicsSeq1
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicsSeq1)
 
         # When subscribing to a different pubsub topic
         let subscribeResponse2 = await wakuFilterClient.subscribe(
@@ -526,9 +522,9 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicsSeq1 & contentTopicsSeq2
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicsSeq1 & contentTopicsSeq2)
 
         # When sending a message to (pubsubTopic, contentTopic)
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -552,7 +548,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic2 == pubsubTopic
           pushedMsg2 == msg2
-        
+
         # When sending a message to (otherPubsubTopic, contentTopic)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg3 = fakeWakuMessage(contentTopic=contentTopic)
@@ -564,7 +560,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic3 == otherPubsubTopic
           pushedMsg3 == msg3
-        
+
         # When sending a message to (otherPubsubTopic, otherContentTopic2)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg4 = fakeWakuMessage(contentTopic=otherContentTopic2)
@@ -576,7 +572,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic4 == otherPubsubTopic
           pushedMsg4 == msg4
-        
+
         # When selectively unsubscribing from (pubsubTopic, otherContentTopic1) and (otherPubsubTopic, contentTopic)
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[otherContentTopic1]
@@ -589,9 +585,9 @@ suite "Waku Filter - End to End":
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @[contentTopic, otherContentTopic2]
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @[contentTopic, otherContentTopic2])
 
         # When sending a message to (pubsubTopic, contentTopic)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
@@ -616,7 +612,7 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic6 == otherPubsubTopic
           pushedMsg6 == msg6
-        
+
         # When sending a message to (pubsubTopic, otherContentTopic1) and (otherPubsubTopic, contentTopic)
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg7 = fakeWakuMessage(contentTopic=otherContentTopic1)
@@ -629,7 +625,7 @@ suite "Waku Filter - End to End":
           not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
 
       asyncTest "Max Topic Size":
-        # Given a topic list of 30 topics
+        # Given a topic list of 100 topics
         var topicSeq: seq[string] = toSeq(0..<MaxContentTopicsPerRequest).mapIt("topic" & $it)
 
         # When subscribing to that topic list
@@ -640,11 +636,11 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId).len == 30
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          wakuFilter.getSubscribedContentTopics(clientPeerId).len == MaxContentTopicsPerRequest
 
-        # When refreshing the subscription with a topic list of 30 topics
+        # When refreshing the subscription with a topic list of 100 topics
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, topicSeq
         )
@@ -652,9 +648,9 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId).len == 30
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          wakuFilter.getSubscribedContentTopics(clientPeerId).len == MaxContentTopicsPerRequest
 
         # When creating a subscription with a topic list of 31 topics
         let subscribeResponse3 = await wakuFilterClient.subscribe(
@@ -665,18 +661,18 @@ suite "Waku Filter - End to End":
         check:
           subscribeResponse3.isErr() # Not subscribed
           subscribeResponse3.error().kind == FilterSubscribeErrorKind.BAD_REQUEST
-        
+
         # And the previous subscription is still active
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId).len == 30
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          wakuFilter.getSubscribedContentTopics(clientPeerId).len == MaxContentTopicsPerRequest
 
-      asyncTest "Max Criteria Per Subscription":  
-        # Given a topic list of size MaxCriteriaPerSubscription
-        var topicSeq: seq[string] = toSeq(0..<MaxCriteriaPerSubscription).mapIt("topic" & $it)
-      
-        # When client service node subscribes to the topic list of size MaxCriteriaPerSubscription
+      asyncTest "Max Criteria Per Subscription":
+        # Given a topic list of size MaxFilterCriteriaPerPeer
+        var topicSeq: seq[string] = toSeq(0..<MaxFilterCriteriaPerPeer).mapIt("topic" & $it)
+
+        # When client service node subscribes to the topic list of size MaxFilterCriteriaPerPeer
         var subscribedTopics: seq[string] = @[]
         while topicSeq.len > 0:
           let takeNumber = min(topicSeq.len, MaxContentTopicsPerRequest)
@@ -687,14 +683,14 @@ suite "Waku Filter - End to End":
           assert subscribeResponse.isOk(), $subscribeResponse.error
           subscribedTopics.add(topicSeqBatch)
           topicSeq.delete(0..<takeNumber)
-      
+
         # Then the subscription is successful
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1000
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          wakuFilter.getSubscribedContentTopics(clientPeerId).len == MaxFilterCriteriaPerPeer
 
-        # When subscribing to a number of topics that exceeds MaxCriteriaPerSubscription
+        # When subscribing to a number of topics that exceeds MaxFilterCriteriaPerPeer
         let subscribeResponse = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, @["topic1000"]
         )
@@ -706,34 +702,41 @@ suite "Waku Filter - End to End":
 
         # And the previous subscription is still active
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1000
 
-      # Takes a long while because it instances a lot of clients. 
-      xasyncTest "Max Total Subscriptions":      
-        # Given a WakuFilterClient list of size MaxTotalSubscriptions
+      # SKIPPED due to it takes a long while because it instances a lot of clients.
+      xasyncTest "Max Total Subscriptions":
+        ## TODO: Revise this, due to the nature of peer management, IP colocation
+        ## and number of allowed connection may not match Filter allowed service peers number.
+        ##  - Rework: as of now timeout/max peers/max subscriptions are configurable, limit the WakuFilter service to lower numbers
+        ##  - Adapt this test to the new limits
+
+        # Given a WakuFilterClient list of size MaxFilterPeers
         var clients: seq[(WakuFilterClient, Switch)] = @[]
-        for i in 0..<MaxTotalSubscriptions:
+        for i in 0..<MaxFilterPeers:
           let standardSwitch = newStandardSwitch()
-          let wakuFilterClient = await newTestWakuFilterClient(standardSwitch, messagePushHandler)
+          let wakuFilterClient = await newTestWakuFilterClient(standardSwitch)
           clients.add((wakuFilterClient, standardSwitch))
-        
+
         # When initialising all of them and subscribing them to the same service
         for (wakuFilterClient, standardSwitch) in clients:
           await standardSwitch.start()
           let subscribeResponse = await wakuFilterClient.subscribe(
-            serverRemotePeerInfo, pubsubTopic, contentTopicSeq
-          )  
-        assert subscribeResponse.isOk(), $subscribeResponse.error
+                                                        serverRemotePeerInfo,
+                                                        pubsubTopic,
+                                                        contentTopicSeq
+                                                      )
+          assert subscribeResponse.isOk(), $subscribeResponse.error
 
-        # Then the service node should have MaxTotalSubscriptions subscriptions
+        # Then the service node should have MaxFilterPeers subscriptions
         check:
-          wakuFilter.subscriptions.len == 1000
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == MaxFilterPeers
+
         # When initialising a new WakuFilterClient and subscribing it to the same service
         let standardSwitch = newStandardSwitch()
-        let wakuFilterClient = await newTestWakuFilterClient(standardSwitch, messagePushHandler)
+        let wakuFilterClient = await newTestWakuFilterClient(standardSwitch)
         await standardSwitch.start()
         let subscribeResponse = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -757,9 +760,9 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When subscribing to the second service node
         let subscriptionResponse2 = await wakuFilterClient.subscribe(
@@ -769,15 +772,15 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscriptionResponse2.isOk(), $subscriptionResponse2.error
         check:
-          wakuFilter2.subscriptions.len == 1
-          wakuFilter2.subscriptions.hasKey(clientPeerId)
-          wakuFilter2.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
-        
+          wakuFilter2.subscriptions.subscribedPeerCount() == 1
+          wakuFilter2.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter2.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
+
         # And the first service node is still subscribed
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When sending a message to the subscribed content topic on the first service node
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -803,16 +806,16 @@ suite "Waku Filter - End to End":
           pushedMsg2 == msg2
 
       asyncTest "Refreshing Subscription":
-        # Given a valid subscription  
+        # Given a valid subscription
         let subscribeResponse1 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
+
         # When refreshing the subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -821,9 +824,9 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
 
         # When sending a message to the refreshed subscription
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -844,7 +847,7 @@ suite "Waku Filter - End to End":
 
       asyncTest "Overlapping Topic Subscription":
         # Given a set of overlapping subscriptions
-        let 
+        let
           subscribeResponse1 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, contentTopicSeq
           )
@@ -858,7 +861,7 @@ suite "Waku Filter - End to End":
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         assert subscribeResponse3.isOk(), $subscribeResponse3.error
         check:
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When sending a message to the overlapping subscription 1
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -932,10 +935,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
+
         # When unsubscribing from the subscription
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -944,8 +947,8 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
+
       asyncTest "After refreshing a subscription with Single Content Topic":
         # Given a valid subscription
         let subscribeResponse1 = await wakuFilterClient.subscribe(
@@ -953,10 +956,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
+
         # When refreshing the subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -965,10 +968,10 @@ suite "Waku Filter - End to End":
         # Then the subscription is successful
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == contentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), contentTopicSeq)
+
         # When unsubscribing from the subscription
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -977,7 +980,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "PubSub Topic with Multiple Content Topics, One By One":
         # Given a valid subscription
@@ -987,10 +990,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from one of the content topics
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
@@ -999,10 +1002,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @["other-content-topic"]
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @["other-content-topic"])
+
         # When unsubscribing from the other content topic
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1011,8 +1014,8 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
-      
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
+
       asyncTest "PubSub Topic with Multiple Content Topics, All At Once":
         # Given a valid subscription
         let multipleContentTopicSeq = @[contentTopic, "other-content-topic"]
@@ -1021,10 +1024,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from all content topics
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1033,7 +1036,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a complete subscription with Multiple Content Topics, One By One":
         # Given a valid subscription
@@ -1043,10 +1046,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # And a successful complete refresh of the subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1054,10 +1057,10 @@ suite "Waku Filter - End to End":
 
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from one of the content topics
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
@@ -1066,10 +1069,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @["other-content-topic"]
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @["other-content-topic"])
+
         # When unsubscribing from the other content topic
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1078,7 +1081,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a complete subscription with Multiple Content Topics, All At Once":
         # Given a valid subscription
@@ -1088,10 +1091,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # And a successful complete refresh of the subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1099,10 +1102,10 @@ suite "Waku Filter - End to End":
 
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from all content topics
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1111,7 +1114,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a partial subscription with Multiple Content Topics, One By One":
         # Given a valid subscription
@@ -1121,19 +1124,19 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # Unsubscribing from one content topic
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
         )
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @["other-content-topic"]
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @["other-content-topic"])
 
         # And a successful refresh of the partial subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
@@ -1141,10 +1144,10 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from one of the content topics
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
@@ -1153,10 +1156,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @["other-content-topic"]
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @["other-content-topic"])
+
         # When unsubscribing from the other content topic
         let unsubscribeResponse3 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1165,7 +1168,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse3.isOk(), $unsubscribeResponse3.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a partial subscription with Multiple Content Topics, All At Once":
         # Given a valid subscription
@@ -1175,30 +1178,30 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # Unsubscribing from one content topic
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
         )
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == @["other-content-topic"]
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), @["other-content-topic"])
+
         # And a successful refresh of the partial subscription
         let subscribeResponse2 = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
         )
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-          wakuFilter.getSubscribedContentTopics(clientPeerId) == multipleContentTopicSeq
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+          unorderedCompare(wakuFilter.getSubscribedContentTopics(clientPeerId), multipleContentTopicSeq)
+
         # When unsubscribing from all content topics
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1207,7 +1210,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       ###
       # Multiple PubSub Topics
@@ -1222,14 +1225,14 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", contentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -1238,10 +1241,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", contentTopicSeq
@@ -1250,8 +1253,8 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
+
       asyncTest "Different PubSub Topics with Multiple (Same) Content Topics, One By One":
         # Given two valid subscriptions with the same content topics
         let
@@ -1262,14 +1265,14 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
@@ -1278,10 +1281,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 3
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @["other-content-topic"]
@@ -1290,10 +1293,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse3 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1302,10 +1305,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse3.isOk(), $unsubscribeResponse3.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1
-        
+
         # When unsubscribing from the last subscription
         let unsubscribeResponse4 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @[contentTopic]
@@ -1314,7 +1317,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse4.isOk(), $unsubscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "Different PubSub Topics with Multiple (Same) Content Topics, All At Once":
         # Given two valid subscriptions with the same content topics
@@ -1326,12 +1329,12 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
 
         # When unsubscribing from one of the subscriptions
@@ -1342,10 +1345,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
@@ -1354,7 +1357,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a complete subscription with different PubSub Topics and Single (Same) Content Topic":
         # Given two valid subscriptions with the same content topic
@@ -1365,30 +1368,30 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", contentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # And a successful complete refresh of the subscription
-        let 
+        let
           subscribeResponse3 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, contentTopicSeq
           )
           subscribeResponse4 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", contentTopicSeq
           )
-        
+
         assert subscribeResponse3.isOk(), $subscribeResponse3.error
         assert subscribeResponse4.isOk(), $subscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
@@ -1397,10 +1400,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", contentTopicSeq
@@ -1409,7 +1412,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a complete subscription with different PubSub Topics and Multiple (Same) Content Topics, One By One":
         # Given two valid subscriptions with the same content topics
@@ -1421,30 +1424,30 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # And a successful complete refresh of the subscription
-        let 
+        let
           subscribeResponse3 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
           )
           subscribeResponse4 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse3.isOk(), $subscribeResponse3.error
         assert subscribeResponse4.isOk(), $subscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @[contentTopic]
@@ -1453,10 +1456,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 3
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @["other-content-topic"]
@@ -1465,10 +1468,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse3 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1477,19 +1480,19 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse3.isOk(), $unsubscribeResponse3.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1
-        
+
         # When unsubscribing from the last subscription
         let unsubscribeResponse4 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @[contentTopic]
         )
-      
+
         # Then the unsubscription is successful
         assert unsubscribeResponse4.isOk(), $unsubscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a complete subscription with different PubSub Topics and Multiple (Same) Content Topics, All At Once":
         # Given two valid subscriptions with the same content topics
@@ -1501,30 +1504,30 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # And a successful complete refresh of the subscription
-        let 
+        let
           subscribeResponse3 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
           )
           subscribeResponse4 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse3.isOk(), $subscribeResponse3.error
         assert subscribeResponse4.isOk(), $subscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1533,10 +1536,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
@@ -1545,7 +1548,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a partial subscription with different PubSub Topics and Multiple (Same) Content Topics, One By One":
         # Given two valid subscriptions with the same content topics
@@ -1557,14 +1560,14 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # Unsubscribing from one of the content topics of each subscription
         let
           unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
@@ -1573,28 +1576,28 @@ suite "Waku Filter - End to End":
           unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
             serverRemotePeerInfo, "other-pubsub-topic", @["other-content-topic"]
           )
-        
+
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # And a successful refresh of the partial subscription
-        let 
+        let
           refreshSubscriptionResponse1 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
           )
           refreshSubscriptionResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert refreshSubscriptionResponse1.isOk(), $refreshSubscriptionResponse1.error
         assert refreshSubscriptionResponse2.isOk(), $refreshSubscriptionResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
 
         # When unsubscribing from one of the subscriptions
@@ -1605,10 +1608,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse3.isOk(), $unsubscribeResponse3.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 3
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse4 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @["other-content-topic"]
@@ -1617,10 +1620,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse4.isOk(), $unsubscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from another of the subscriptions
         let unsubscribeResponse5 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, @["other-content-topic"]
@@ -1629,10 +1632,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse5.isOk(), $unsubscribeResponse5.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 1
-        
+
         # When unsubscribing from the last subscription
         let unsubscribeResponse6 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", @[contentTopic]
@@ -1641,7 +1644,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse6.isOk(), $unsubscribeResponse6.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "After refreshing a partial subscription with different PubSub Topics and Multiple (Same) Content Topics, All At Once":
         # Given two valid subscriptions with the same content topics
@@ -1653,14 +1656,14 @@ suite "Waku Filter - End to End":
           subscribeResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # Unsubscribing from one of the content topics of each subscription
         let
           unsubscribeResponse1 = await wakuFilterClient.unsubscribe(
@@ -1669,30 +1672,30 @@ suite "Waku Filter - End to End":
           unsubscribeResponse2 = await wakuFilterClient.unsubscribe(
             serverRemotePeerInfo, "other-pubsub-topic", @["other-content-topic"]
           )
-        
+
         assert unsubscribeResponse1.isOk(), $unsubscribeResponse1.error
         assert unsubscribeResponse2.isOk(), $unsubscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # And a successful refresh of the partial subscription
-        let 
+        let
           refreshSubscriptionResponse1 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
           )
           refreshSubscriptionResponse2 = await wakuFilterClient.subscribe(
             serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
           )
-        
+
         assert refreshSubscriptionResponse1.isOk(), $refreshSubscriptionResponse1.error
         assert refreshSubscriptionResponse2.isOk(), $refreshSubscriptionResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 4
-        
+
         # When unsubscribing from one of the subscriptions
         let unsubscribeResponse3 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, pubsubTopic, multipleContentTopicSeq
@@ -1701,10 +1704,10 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse3.isOk(), $unsubscribeResponse3.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
           wakuFilter.getSubscribedContentTopics(clientPeerId).len == 2
-        
+
         # When unsubscribing from the other subscription
         let unsubscribeResponse4 = await wakuFilterClient.unsubscribe(
           serverRemotePeerInfo, "other-pubsub-topic", multipleContentTopicSeq
@@ -1713,7 +1716,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse4.isOk(), $unsubscribeResponse4.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "Without existing subscription":
         # When unsubscribing from a non-existent subscription
@@ -1733,8 +1736,8 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When unsubscribing from a pubsub topic that does not exist
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
@@ -1753,8 +1756,8 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When unsubscribing from a content topic that does not exist
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
@@ -1765,7 +1768,7 @@ suite "Waku Filter - End to End":
         check:
           unsubscribeResponse.isErr() # Not subscribed
           unsubscribeResponse.error().kind == FilterSubscribeErrorKind.NOT_FOUND
-      
+
       asyncTest "Empty content topic":
         # Given a valid subscription
         let subscribeResponse = await wakuFilterClient.subscribe(
@@ -1773,8 +1776,8 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When unsubscribing from an empty content topic
         let unsubscribeResponse = await wakuFilterClient.unsubscribe(
@@ -1794,9 +1797,9 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
         # When unsubscribing from all topics
         let unsubscribeResponse = await wakuFilterClient.unsubscribeAll(
           serverRemotePeerInfo
@@ -1805,7 +1808,7 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "Unsubscribe from All Topics, Multiple PubSub Topics":
         # Given a valid subscription
@@ -1818,9 +1821,9 @@ suite "Waku Filter - End to End":
         assert subscribeResponse1.isOk(), $subscribeResponse1.error
         assert subscribeResponse2.isOk(), $subscribeResponse2.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
         # When unsubscribing from all topics
         let unsubscribeResponse = await wakuFilterClient.unsubscribeAll(
           serverRemotePeerInfo
@@ -1829,12 +1832,12 @@ suite "Waku Filter - End to End":
         # Then the unsubscription is successful
         assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
       asyncTest "Unsubscribe from All Topics from a non-subscribed Service":
         # Given the client is not subscribed to a service
         check:
-          wakuFilter.subscriptions.len == 0
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
 
         # When unsubscribing from all topics for that client
         let unsubscribeResponse = await wakuFilterClient.unsubscribeAll(
@@ -1854,8 +1857,8 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # And some extra payloads
         let
@@ -1863,7 +1866,7 @@ suite "Waku Filter - End to End":
           JSON_LIST = getSampleJsonList()
 
         # And some valid messages
-        let 
+        let
           msg1 = fakeWakuMessage(contentTopic=contentTopic, payload=ALPHABETIC)
           msg2 = fakeWakuMessage(contentTopic=contentTopic, payload=ALPHANUMERIC)
           msg3 = fakeWakuMessage(contentTopic=contentTopic, payload=ALPHANUMERIC_SPECIAL)
@@ -1874,7 +1877,7 @@ suite "Waku Filter - End to End":
           msg8 = fakeWakuMessage(contentTopic=contentTopic, payload= $JSON_LIST)
           msg9 = fakeWakuMessage(contentTopic=contentTopic, payload=TEXT_SMALL)
           msg10 = fakeWakuMessage(contentTopic=contentTopic, payload=TEXT_LARGE)
-        
+
         # When sending the alphabetic message
         await wakuFilter.handleMessage(pubsubTopic, msg1)
 
@@ -1886,7 +1889,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic1 == pubsubTopic
           pushedMsg1 == msg1
           msg1.payload.toString() == ALPHABETIC
-        
+
         # When sending the alphanumeric message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg2)
@@ -1898,7 +1901,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic2 == pubsubTopic
           pushedMsg2 == msg2
           msg2.payload.toString() == ALPHANUMERIC
-        
+
         # When sending the alphanumeric special message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg3)
@@ -1934,7 +1937,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic5 == pubsubTopic
           pushedMsg5 == msg5
           msg5.payload.toString() == CODE
-        
+
         # When sending the query message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg6)
@@ -1946,7 +1949,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic6 == pubsubTopic
           pushedMsg6 == msg6
           msg6.payload.toString() == QUERY
-        
+
         # When sending the table message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg7)
@@ -1958,7 +1961,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic7 == pubsubTopic
           pushedMsg7 == msg7
           msg7.payload.toString() == $JSON_DICTIONARY
-        
+
         # When sending the list message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg8)
@@ -1970,7 +1973,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic8 == pubsubTopic
           pushedMsg8 == msg8
           msg8.payload.toString() == $JSON_LIST
-        
+
         # When sending the small text message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg9)
@@ -1982,7 +1985,7 @@ suite "Waku Filter - End to End":
           pushedMsgPubsubTopic9 == pubsubTopic
           pushedMsg9 == msg9
           msg9.payload.toString() == TEXT_SMALL
-        
+
         # When sending the large text message
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         await wakuFilter.handleMessage(pubsubTopic, msg10)
@@ -2002,13 +2005,13 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # Given some valid payloads
         let
           msg1 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(1024)) # 1KiB
-          msg2 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(10*1024)) # 10KiB 
+          msg2 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(10*1024)) # 10KiB
           msg3 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(100*1024)) # 100KiB
           msg4 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(MaxRpcSize - 1024)) # Max Size (Inclusive Limit)
           msg5 = fakeWakuMessage(contentTopic=contentTopic, payload=getByteSequence(MaxRpcSize)) # Max Size (Exclusive Limit)
@@ -2067,26 +2070,26 @@ suite "Waku Filter - End to End":
       asyncTest "Filter Client can receive messages after Client and Server reboot":
         # Given a clean client and server
         check:
-          wakuFilter.subscriptions.len == 0
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 0
+
         # When subscribing to a topic
         let subscribeResponse = await wakuFilterClient.subscribe(
           serverRemotePeerInfo, pubsubTopic, contentTopicSeq
         )
-        
+
         # Then the subscription is successful
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
         # When both are stopped and started
         waitFor allFutures(wakuFilter.stop(), wakuFilterClient.stop())
         waitFor allFutures(wakuFilter.start(), wakuFilterClient.start())
 
         # Then the suscription is maintained
         check:
-          wakuFilter.subscriptions.len == 1
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
 
         # When sending a message to the subscription
         let msg1 = fakeWakuMessage(contentTopic=contentTopic)
@@ -2107,9 +2110,9 @@ suite "Waku Filter - End to End":
         # Then the refreshment is successful
         assert refreshSubscriptionResponse.isOk(), $refreshSubscriptionResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
         # When sending a message to the refreshed subscription
         pushHandlerFuture = newPushHandlerFuture() # Clear previous future
         let msg2 = fakeWakuMessage(contentTopic=contentTopic)
@@ -2129,16 +2132,16 @@ suite "Waku Filter - End to End":
         )
         assert subscribeResponse.isOk(), $subscribeResponse.error
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
-        
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
         # When the client is stopped
         await wakuFilterClient.stop()
 
         # Then the subscription is not removed
         check:
-          wakuFilter.subscriptions.len == 1
-          wakuFilter.subscriptions.hasKey(clientPeerId)
+          wakuFilter.subscriptions.subscribedPeerCount() == 1
+          wakuFilter.subscriptions.isSubscribed(clientPeerId)
 
         # When the server receives a message
         let msg = fakeWakuMessage(contentTopic=contentTopic)
@@ -2150,3 +2153,344 @@ suite "Waku Filter - End to End":
         check:
           pushedMsgPubsubTopic == pubsubTopic
           pushedMsg == msg
+
+  suite "Subscription timeout":
+    var serverSwitch {.threadvar.}: Switch
+    var clientSwitch {.threadvar.}: Switch
+    var clientSwitch2nd {.threadvar.}: Switch
+    var wakuFilter {.threadvar.}: WakuFilter
+    var wakuFilterClient {.threadvar.}: WakuFilterClient
+    var wakuFilterClient2nd {.threadvar.}: WakuFilterClient
+    var serverRemotePeerInfo {.threadvar.}: RemotePeerInfo
+    var pubsubTopic {.threadvar.}: PubsubTopic
+    var contentTopic {.threadvar.}: ContentTopic
+    var contentTopicSeq {.threadvar.}: seq[ContentTopic]
+    var clientPeerId {.threadvar.}: PeerId
+    var clientPeerId2nd {.threadvar.}: PeerId
+    var messagePushHandler {.threadvar.}: FilterPushHandler
+    var messagePushHandler2nd {.threadvar.}: FilterPushHandler
+    var msgSeq {.threadvar.}: seq[(PubsubTopic, WakuMessage)]
+    var msgSeq2nd {.threadvar.}: seq[(PubsubTopic, WakuMessage)]
+    var pushHandlerFuture {.threadvar.}: Future[(PubsubTopic, WakuMessage)]
+    var pushHandlerFuture2nd {.threadvar.}: Future[(PubsubTopic, WakuMessage)]
+
+    asyncSetup:
+      msgSeq = @[]
+      pushHandlerFuture = newPushHandlerFuture()
+      messagePushHandler = proc(
+        pubsubTopic: PubsubTopic, message: WakuMessage
+      ): Future[void] {.async, closure.} =
+        msgSeq.add((pubsubTopic, message))
+        pushHandlerFuture.complete((pubsubTopic, message))
+
+      msgSeq2nd = @[]
+      pushHandlerFuture2nd = newPushHandlerFuture()
+      messagePushHandler2nd = proc(
+        pubsubTopic: PubsubTopic, message: WakuMessage
+      ): Future[void] {.async, closure, gcsafe.} =
+        msgSeq2nd.add((pubsubTopic, message))
+        pushHandlerFuture2nd.complete((pubsubTopic, message))
+
+      pubsubTopic = DefaultPubsubTopic
+      contentTopic = DefaultContentTopic
+      contentTopicSeq = @[contentTopic]
+      serverSwitch = newStandardSwitch()
+      clientSwitch = newStandardSwitch()
+      clientSwitch2nd = newStandardSwitch()
+      wakuFilter = await newTestWakuFilter(serverSwitch, 2.seconds)
+      wakuFilterClient = await newTestWakuFilterClient(clientSwitch)
+      wakuFilterClient2nd = await newTestWakuFilterClient(clientSwitch2nd)
+
+      await allFutures(serverSwitch.start(), clientSwitch.start(), clientSwitch2nd.start())
+      wakuFilterClient.registerPushHandler(messagePushHandler)
+      wakuFilterClient2nd.registerPushHandler(messagePushHandler2nd)
+      serverRemotePeerInfo = serverSwitch.peerInfo.toRemotePeerInfo()
+      clientPeerId = clientSwitch.peerInfo.toRemotePeerInfo().peerId
+      clientPeerId2nd = clientSwitch2nd.peerInfo.toRemotePeerInfo().peerId
+
+    asyncTeardown:
+      await allFutures(wakuFilter.stop(),
+                       wakuFilterClient.stop(),
+                       wakuFilterClient2nd.stop(),
+                       serverSwitch.stop(),
+                       clientSwitch.stop(),
+                       clientSwitch2nd.stop())
+
+    asyncTest "client unsubscribe by timeout":
+      # Given
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic1 == pubsubTopic
+        pushedMsg1 == msg1
+
+      await sleepAsync(2500)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      check:
+        wakuFilter.subscriptions.isSubscribed(clientPeerId) == false
+        not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+
+    asyncTest "client reset subscription timeout with ping":
+      # Given
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic1 == pubsubTopic
+        pushedMsg1 == msg1
+
+      await sleepAsync(1000)
+
+      let pingResponse = await wakuFilterClient.ping(serverRemotePeerInfo)
+
+      assert pingResponse.isOk(), $pingResponse.error
+
+      # wait more in sum of the timeout
+      await sleepAsync(1200)
+
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic2, pushedMsg2) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic2 == pubsubTopic
+        pushedMsg2 == msg2
+
+    asyncTest "client reset subscription timeout with subscribe":
+      # Given
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic1 == pubsubTopic
+        pushedMsg1 == msg1
+
+      await sleepAsync(1000)
+
+      let contentTopic2nd = "content-topic-2nd"
+      contentTopicSeq = @[contentTopic2nd]
+      let subscribeResponse2nd = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+
+      assert subscribeResponse2nd.isOk(), $subscribeResponse2nd.error
+
+      # wait more in sum of the timeout
+      await sleepAsync(1200)
+
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic2nd)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic2, pushedMsg2) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic2 == pubsubTopic
+        pushedMsg2 == msg2
+
+    asyncTest "client reset subscription timeout with unsubscribe":
+      # Given
+      let contentTopic2nd = "content-topic-2nd"
+      contentTopicSeq.add(contentTopic2nd)
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic2nd)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic1 == pubsubTopic
+        pushedMsg1 == msg1
+
+      await sleepAsync(1000)
+
+      contentTopicSeq = @[contentTopic2nd]
+      let unsubscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+
+      assert unsubscribeResponse.isOk(), $unsubscribeResponse.error
+
+      # wait more in sum of the timeout
+      await sleepAsync(1200)
+
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      # shall still receive message on default content topic
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic2, pushedMsg2) = pushHandlerFuture.read()
+      check:
+        pushedMsgPubsubTopic2 == pubsubTopic
+        pushedMsg2 == msg2
+
+    asyncTest "two clients shifted subscription and timeout":
+      # Given
+      let contentTopic2nd = "content-topic-2nd"
+      contentTopicSeq.add(contentTopic2nd)
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      await sleepAsync(1000)
+
+      let
+        subscribeResponse2nd = await wakuFilterClient2nd.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+
+      assert subscribeResponse2nd.isOk(), $subscribeResponse2nd.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId2nd)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      pushHandlerFuture2nd = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic2nd)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+
+      # both clients get messages
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      check await pushHandlerFuture2nd.withTimeout(FUTURE_TIMEOUT)
+      block:
+        let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+        check:
+          pushedMsgPubsubTopic1 == pubsubTopic
+          pushedMsg1 == msg1
+      block:
+        let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture2nd.read()
+        check:
+          pushedMsgPubsubTopic1 == pubsubTopic
+          pushedMsg1 == msg1
+
+      await sleepAsync(1200)
+
+      check not wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      pushHandlerFuture2nd = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      # shall still receive message on default content topic
+      check not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      check await pushHandlerFuture2nd.withTimeout(FUTURE_TIMEOUT)
+      let (pushedMsgPubsubTopic2, pushedMsg2) = pushHandlerFuture2nd.read()
+      check:
+        pushedMsgPubsubTopic2 == pubsubTopic
+        pushedMsg2 == msg2
+
+      await sleepAsync(1000)
+
+      check not wakuFilter.subscriptions.isSubscribed(clientPeerId2nd)
+
+    asyncTest "two clients timeout maintenance":
+      # Given
+      let contentTopic2nd = "content-topic-2nd"
+      contentTopicSeq.add(contentTopic2nd)
+      let
+        subscribeResponse = await wakuFilterClient.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+      assert subscribeResponse.isOk(), $subscribeResponse.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId)
+
+      let
+        subscribeResponse2nd = await wakuFilterClient2nd.subscribe(
+          serverRemotePeerInfo, pubsubTopic, contentTopicSeq
+        )
+
+      assert subscribeResponse2nd.isOk(), $subscribeResponse2nd.error
+      check wakuFilter.subscriptions.isSubscribed(clientPeerId2nd)
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      pushHandlerFuture2nd = newPushHandlerFuture() # Clear previous future
+      let msg1 = fakeWakuMessage(contentTopic=contentTopic2nd)
+      await wakuFilter.handleMessage(pubsubTopic, msg1)
+
+      # both clients get messages
+      check await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      check await pushHandlerFuture2nd.withTimeout(FUTURE_TIMEOUT)
+      block:
+        let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture.read()
+        check:
+          pushedMsgPubsubTopic1 == pubsubTopic
+          pushedMsg1 == msg1
+      block:
+        let (pushedMsgPubsubTopic1, pushedMsg1) = pushHandlerFuture2nd.read()
+        check:
+          pushedMsgPubsubTopic1 == pubsubTopic
+          pushedMsg1 == msg1
+
+      await sleepAsync(2200)
+
+      wakuFilter.maintainSubscriptions()
+
+      check not wakuFilter.subscriptions.isSubscribed(clientPeerId)
+      check not wakuFilter.subscriptions.isSubscribed(clientPeerId2nd)
+
+
+
+      pushHandlerFuture = newPushHandlerFuture() # Clear previous future
+      pushHandlerFuture2nd = newPushHandlerFuture() # Clear previous future
+      let msg2 = fakeWakuMessage(contentTopic=contentTopic)
+      await wakuFilter.handleMessage(pubsubTopic, msg2)
+
+      # shall still receive message on default content topic
+      check not await pushHandlerFuture.withTimeout(FUTURE_TIMEOUT)
+      check not await pushHandlerFuture2nd.withTimeout(FUTURE_TIMEOUT)
+
diff --git a/tests/waku_filter_v2/test_waku_filter_protocol.nim b/tests/waku_filter_v2/test_waku_filter_protocol.nim
index b4eb15a74..a2c441af6 100644
--- a/tests/waku_filter_v2/test_waku_filter_protocol.nim
+++ b/tests/waku_filter_v2/test_waku_filter_protocol.nim
@@ -13,7 +13,8 @@ import
   ../../../waku/waku_filter_v2/subscriptions,
   ../../../waku/waku_core,
   ../testlib/common,
-  ../testlib/wakucore
+  ../testlib/wakucore,
+  ./waku_filter_utils
 
 proc newTestWakuFilter(switch: Switch): WakuFilter =
   let
@@ -38,9 +39,11 @@ proc createRequest(filterSubscribeType: FilterSubscribeType, pubsubTopic = none(
   )
 
 proc getSubscribedContentTopics(wakuFilter: WakuFilter, peerId: PeerId): seq[ContentTopic] =
-  var contentTopics: seq[ContentTopic]
-  for filterCriterion in wakuFilter.subscriptions[peerId]:
-    contentTopics.add(filterCriterion[1])
+  var contentTopics: seq[ContentTopic] = @[]
+  let peersCreitera = wakuFilter.subscriptions.getPeerSubscriptions(peerId)
+
+  for filterCriterion in peersCreitera:
+    contentTopics.add(filterCriterion.contentTopic)
 
   return contentTopics
 
@@ -68,8 +71,8 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions[peerId].len == 1
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.peersSubscribed[peerId].criteriaCount == 1
       response.requestId == filterSubscribeRequest.requestId
       response.statusCode == 200
       response.statusDesc.get() == "OK"
@@ -79,7 +82,7 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 0 # peerId is removed from subscriptions
+      wakuFilter.subscriptions.subscribedPeerCount() == 0 # peerId is removed from subscriptions
       response2.requestId == filterUnsubscribeRequest.requestId
       response2.statusCode == 200
       response2.statusDesc.get() == "OK"
@@ -105,9 +108,9 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions[peerId].len == 2
-      wakuFilter.getSubscribedContentTopics(peerId) == filterSubscribeRequest.contentTopics
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.peersSubscribed[peerId].criteriaCount == 2
+      unorderedCompare(wakuFilter.getSubscribedContentTopics(peerId), filterSubscribeRequest.contentTopics)
       response.requestId == filterSubscribeRequest.requestId
       response.statusCode == 200
       response.statusDesc.get() == "OK"
@@ -117,7 +120,7 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 0 # peerId is removed from subscriptions
+      wakuFilter.subscriptions.subscribedPeerCount() == 0 # peerId is removed from subscriptions
       response2.requestId == filterUnsubscribeAllRequest.requestId
       response2.statusCode == 200
       response2.statusDesc.get() == "OK"
@@ -155,9 +158,9 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions[peerId].len == 1
-      wakuFilter.getSubscribedContentTopics(peerId) == filterSubscribeRequest1.contentTopics
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.peersSubscribed[peerId].criteriaCount == 1
+      unorderedCompare(wakuFilter.getSubscribedContentTopics(peerId), filterSubscribeRequest1.contentTopics)
       response1.requestId == filterSubscribeRequest1.requestId
       response1.statusCode == 200
       response1.statusDesc.get() == "OK"
@@ -167,11 +170,11 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions[peerId].len == 2
-      wakuFilter.getSubscribedContentTopics(peerId) ==
-        filterSubscribeRequest1.contentTopics &
-        filterSubscribeRequest2.contentTopics
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.peersSubscribed[peerId].criteriaCount == 2
+      unorderedCompare(wakuFilter.getSubscribedContentTopics(peerId),
+                    filterSubscribeRequest1.contentTopics &
+                      filterSubscribeRequest2.contentTopics)
       response2.requestId == filterSubscribeRequest2.requestId
       response2.statusCode == 200
       response2.statusDesc.get() == "OK"
@@ -181,9 +184,9 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions[peerId].len == 1
-      wakuFilter.getSubscribedContentTopics(peerId) == filterSubscribeRequest2.contentTopics
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.peersSubscribed[peerId].criteriaCount == 1
+      unorderedCompare(wakuFilter.getSubscribedContentTopics(peerId), filterSubscribeRequest2.contentTopics)
       response3.requestId == filterUnsubscribeRequest1.requestId
       response3.statusCode == 200
       response3.statusDesc.get() == "OK"
@@ -193,7 +196,7 @@ suite "Waku Filter - handling subscribe requests":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 0 # peerId is removed from subscriptions
+      wakuFilter.subscriptions.subscribedPeerCount() == 0 # peerId is removed from subscriptions
       response4.requestId == filterUnsubscribeRequest2.requestId
       response4.statusCode == 200
       response4.statusDesc.get() == "OK"
@@ -255,9 +258,9 @@ suite "Waku Filter - handling subscribe requests":
 
     # When
     let
-      filterCriteria = toSeq(1 .. MaxCriteriaPerSubscription + 1).mapIt((DefaultPubsubTopic, ContentTopic("/waku/2/content-$#/proto" % [$it])))
+      filterCriteria = toSeq(1 .. MaxFilterCriteriaPerPeer).mapIt((DefaultPubsubTopic, ContentTopic("/waku/2/content-$#/proto" % [$it])))
 
-    wakuFilter.subscriptions[peerId] = filterCriteria.toHashSet()
+    discard wakuFilter.subscriptions.addSubscription(peerId, filterCriteria.toHashSet())
 
     let
       reqTooManyFilterCriteria = createRequest(
@@ -276,9 +279,11 @@ suite "Waku Filter - handling subscribe requests":
     ## Max subscriptions exceeded
 
     # When
-    wakuFilter.subscriptions.clear()
-    for _ in 1 .. MaxTotalSubscriptions:
-      wakuFilter.subscriptions[PeerId.random().get()] = @[(DefaultPubsubTopic, DefaultContentTopic)].toHashSet()
+    wakuFilter.subscriptions.removePeer(peerId)
+    wakuFilter.subscriptions.cleanUp()
+
+    for _ in 1 .. MaxFilterPeers:
+      discard wakuFilter.subscriptions.addSubscription(PeerId.random().get(), @[(DefaultPubsubTopic, DefaultContentTopic)].toHashSet())
 
     let
       reqTooManySubscriptions = createRequest(
@@ -443,10 +448,10 @@ suite "Waku Filter - subscription maintenance":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 3
-      wakuFilter.subscriptions.hasKey(peerId1)
-      wakuFilter.subscriptions.hasKey(peerId2)
-      wakuFilter.subscriptions.hasKey(peerId3)
+      wakuFilter.subscriptions.subscribedPeerCount() == 3
+      wakuFilter.subscriptions.isSubscribed(peerId1)
+      wakuFilter.subscriptions.isSubscribed(peerId2)
+      wakuFilter.subscriptions.isSubscribed(peerId3)
 
     # When
     # Maintenance loop should leave all peers in peer store intact
@@ -454,10 +459,10 @@ suite "Waku Filter - subscription maintenance":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 3
-      wakuFilter.subscriptions.hasKey(peerId1)
-      wakuFilter.subscriptions.hasKey(peerId2)
-      wakuFilter.subscriptions.hasKey(peerId3)
+      wakuFilter.subscriptions.subscribedPeerCount() == 3
+      wakuFilter.subscriptions.isSubscribed(peerId1)
+      wakuFilter.subscriptions.isSubscribed(peerId2)
+      wakuFilter.subscriptions.isSubscribed(peerId3)
 
     # When
     # Remove peerId1 and peerId3 from peer store
@@ -467,8 +472,8 @@ suite "Waku Filter - subscription maintenance":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 1
-      wakuFilter.subscriptions.hasKey(peerId2)
+      wakuFilter.subscriptions.subscribedPeerCount() == 1
+      wakuFilter.subscriptions.isSubscribed(peerId2)
 
     # When
     # Remove peerId2 from peer store
@@ -477,4 +482,4 @@ suite "Waku Filter - subscription maintenance":
 
     # Then
     check:
-      wakuFilter.subscriptions.len == 0
+      wakuFilter.subscriptions.subscribedPeerCount() == 0
diff --git a/tests/waku_filter_v2/waku_filter_utils.nim b/tests/waku_filter_v2/waku_filter_utils.nim
index 70d2368bc..7708acd64 100644
--- a/tests/waku_filter_v2/waku_filter_utils.nim
+++ b/tests/waku_filter_v2/waku_filter_utils.nim
@@ -1,17 +1,21 @@
 import
   std/[
-    options, 
+    options,
     tables,
-    sets
+    sets,
+    sequtils,
+    algorithm
   ],
   chronos,
-  chronicles
+  chronicles,
+  os
 
 import
   ../../../waku/[
     node/peer_manager,
     waku_filter_v2,
     waku_filter_v2/client,
+    waku_filter_v2/subscriptions,
     waku_core
   ],
   ../testlib/[
@@ -20,10 +24,14 @@ import
   ]
 
 
-proc newTestWakuFilter*(switch: Switch): Future[WakuFilter] {.async.} =
+proc newTestWakuFilter*(switch: Switch,
+                        subscriptionTimeout: Duration = DefaultSubscriptionTimeToLiveSec,
+                        maxFilterPeers: uint32 = MaxFilterPeers,
+                        maxFilterCriteriaPerPeer: uint32 = MaxFilterCriteriaPerPeer):
+                    Future[WakuFilter] {.async.} =
   let
     peerManager = PeerManager.new(switch)
-    proto = WakuFilter.new(peerManager)
+    proto = WakuFilter.new(peerManager, subscriptionTimeout, maxFilterPeers, maxFilterCriteriaPerPeer)
 
   await proto.start()
   switch.mount(proto)
@@ -41,8 +49,21 @@ proc newTestWakuFilterClient*(switch: Switch): Future[WakuFilterClient] {.async.
   return proto
 
 proc getSubscribedContentTopics*(wakuFilter: WakuFilter, peerId: PeerId): seq[ContentTopic] =
-  var contentTopics: seq[ContentTopic]
-  for filterCriterion in wakuFilter.subscriptions[peerId]:
-    contentTopics.add(filterCriterion[1])
+  var contentTopics: seq[ContentTopic] = @[]
+  let peersCriteria = wakuFilter.subscriptions.getPeerSubscriptions(peerId)
+
+  for filterCriterion in peersCriteria:
+    contentTopics.add(filterCriterion.contentTopic)
 
   return contentTopics
+
+proc unorderedCompare*[T](a, b: seq[T]): bool =
+  if a == b:
+    return true
+
+  var aSorted = a
+  var bSorted = b
+  aSorted.sort()
+  bSorted.sort()
+
+  return aSorted == bSorted
diff --git a/tests/waku_store/test_wakunode_store.nim b/tests/waku_store/test_wakunode_store.nim
index 6c52d853c..9ef9aadab 100644
--- a/tests/waku_store/test_wakunode_store.nim
+++ b/tests/waku_store/test_wakunode_store.nim
@@ -206,6 +206,7 @@ procSuite "WakuNode - Store":
     waitFor allFutures(client.start(), server.start(), filterSource.start())
 
     waitFor filterSource.mountFilter()
+    waitFor filterSource.mountLegacyFilter()
     let driver = newSqliteArchiveDriver()
 
     let mountArchiveRes = server.mountArchive(driver)
diff --git a/tests/wakunode_jsonrpc/test_jsonrpc_admin.nim b/tests/wakunode_jsonrpc/test_jsonrpc_admin.nim
index 9570ab0d0..182d6abe7 100644
--- a/tests/wakunode_jsonrpc/test_jsonrpc_admin.nim
+++ b/tests/wakunode_jsonrpc/test_jsonrpc_admin.nim
@@ -154,6 +154,7 @@ procSuite "Waku v2 JSON-RPC API - Admin":
     await client.connect("127.0.0.1", rpcPort, false)
 
     await node.mountFilter()
+    await node.mountLegacyFilter()
     await node.mountFilterClient()
     let driver: ArchiveDriver = QueueDriver.new()
     let mountArchiveRes = node.mountArchive(driver)
diff --git a/tests/wakunode_jsonrpc/test_jsonrpc_filter.nim b/tests/wakunode_jsonrpc/test_jsonrpc_filter.nim
index 74177f2a0..0c44a1e48 100644
--- a/tests/wakunode_jsonrpc/test_jsonrpc_filter.nim
+++ b/tests/wakunode_jsonrpc/test_jsonrpc_filter.nim
@@ -32,6 +32,7 @@ procSuite "Waku v2 JSON-RPC API - Filter":
     await allFutures(node1.start(), node2.start())
 
     await node1.mountFilter()
+    await node1.mountLegacyFilter()
     await node2.mountFilterClient()
 
     node2.peerManager.addServicePeer(node1.peerInfo.toRemotePeerInfo(), WakuLegacyFilterCodec)
diff --git a/tests/wakunode_rest/test_rest_admin.nim b/tests/wakunode_rest/test_rest_admin.nim
index a418e6ab6..684575989 100644
--- a/tests/wakunode_rest/test_rest_admin.nim
+++ b/tests/wakunode_rest/test_rest_admin.nim
@@ -107,10 +107,11 @@ suite "Waku v2 Rest API - Admin":
       pubsubTopicNode2 = DefaultPubsubTopic
       pubsubTopicNode3 = PubsubTopic("/waku/2/custom-waku/proto")
 
+      ## TODO: Note that such checks may depend heavily on the order of the returned data!
       expectedFilterData2 = fmt"(peerId: ""{$peerInfo2}"", filterCriteria:" &
-        fmt" @[(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[0]}""), " &
-        fmt"(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[1]}""), " &
-        fmt"(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[2]}"")]"
+        fmt" @[(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[1]}""), " &
+        fmt"(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[2]}""), " &
+        fmt"(pubsubTopic: ""{pubsubTopicNode2}"", contentTopic: ""{contentFiltersNode2[0]}"")]"
 
       expectedFilterData3 = fmt"(peerId: ""{$peerInfo3}"", filterCriteria:" &
         fmt" @[(pubsubTopic: ""{pubsubTopicNode3}"", contentTopic: ""{contentFiltersNode3[0]}""), " &
@@ -151,4 +152,4 @@ suite "Waku v2 Rest API - Admin":
 
     check:
       getRes.status == 400
-      getRes.data == "Error: Filter Protocol is not mounted to the node"
\ No newline at end of file
+      getRes.data == "Error: Filter Protocol is not mounted to the node"
diff --git a/tests/wakunode_rest/test_rest_filter.nim b/tests/wakunode_rest/test_rest_filter.nim
index 0c35b9f68..da1ef1e7e 100644
--- a/tests/wakunode_rest/test_rest_filter.nim
+++ b/tests/wakunode_rest/test_rest_filter.nim
@@ -11,7 +11,6 @@ import
   ../../waku/waku_core,
   ../../waku/waku_node,
   ../../waku/node/peer_manager,
-  ../../waku/waku_filter,
   ../../waku/waku_api/rest/server,
   ../../waku/waku_api/rest/client,
   ../../waku/waku_api/rest/responses,
diff --git a/tests/wakunode_rest/test_rest_legacy_filter.nim b/tests/wakunode_rest/test_rest_legacy_filter.nim
index 535103e0f..fe82d8117 100644
--- a/tests/wakunode_rest/test_rest_legacy_filter.nim
+++ b/tests/wakunode_rest/test_rest_legacy_filter.nim
@@ -50,6 +50,7 @@ proc setupRestFilter(): Future[RestFilterTest] {.async.} =
   await allFutures(result.filterNode.start(), result.clientNode.start())
 
   await result.filterNode.mountFilter()
+  await result.filterNode.mountLegacyFilter()
   await result.clientNode.mountFilterClient()
 
   result.clientNode.peerManager.addServicePeer(result.filterNode.peerInfo.toRemotePeerInfo()
@@ -174,7 +175,7 @@ suite "Waku v2 Rest API - Filter":
 
       while msg == messages[i]:
         msg = fakeWakuMessage(contentTopic = "content-topic-x", payload = toBytes("TEST-1"))
-      
+
       messages.add(msg)
 
     restFilterTest.messageCache.contentSubscribe(contentTopic)
diff --git a/waku/node/waku_node.nim b/waku/node/waku_node.nim
index fe7636639..d150d6351 100644
--- a/waku/node/waku_node.nim
+++ b/waku/node/waku_node.nim
@@ -35,6 +35,7 @@ import
   ../waku_filter/client as legacy_filter_client, #TODO: support for legacy filter protocol will be removed
   ../waku_filter_v2,
   ../waku_filter_v2/client as filter_client,
+  ../waku_filter_v2/subscriptions as filter_subscriptions,
   ../waku_lightpush,
   ../waku_metadata,
   ../waku_lightpush/client as lightpush_client,
@@ -67,9 +68,6 @@ const git_version* {.strdefine.} = "n/a"
 # Default clientId
 const clientId* = "Nimbus Waku v2 node"
 
-# Default Waku Filter Timeout
-const WakuFilterTimeout: Duration = 1.days
-
 const WakuNodeVersionString* = "version / git commit hash: " & git_version
 
 # key and crypto modules different
@@ -188,7 +186,7 @@ proc connectToNodes*(node: WakuNode, nodes: seq[RemotePeerInfo] | seq[string], s
 proc mountMetadata*(node: WakuNode, clusterId: uint32): Result[void, string] =
   if not node.wakuMetadata.isNil():
     return err("Waku metadata already mounted, skipping")
-  
+
   let metadata = WakuMetadata.new(clusterId, node.enr, node.topicSubscriptionQueue)
 
   node.wakuMetadata = metadata
@@ -403,18 +401,36 @@ proc mountRelay*(node: WakuNode,
 
 ## Waku filter
 
-proc mountFilter*(node: WakuNode, filterTimeout: Duration = WakuFilterTimeout)
+proc mountLegacyFilter*(node: WakuNode, filterTimeout: Duration = WakuLegacyFilterTimeout)
                  {.async, raises: [Defect, LPError]} =
+  ## Mounting legacy filter protocol with separation from new v2 filter protocol for easier removal later
+  ## TODO: remove legacy filter protocol
+
+  info "mounting legacy filter protocol"
+  node.wakuFilterLegacy = WakuFilterLegacy.new(node.peerManager, node.rng, filterTimeout)
+
+  if node.started:
+    await node.wakuFilterLegacy.start() #TODO: remove legacy
+
+  node.switch.mount(node.wakuFilterLegacy, protocolMatcher(WakuLegacyFilterCodec))
+
+proc mountFilter*(node: WakuNode,
+                  subscriptionTimeout: Duration = filter_subscriptions.DefaultSubscriptionTimeToLiveSec,
+                  maxFilterPeers: uint32 = filter_subscriptions.MaxFilterPeers,
+                  maxFilterCriteriaPerPeer: uint32 = filter_subscriptions.MaxFilterCriteriaPerPeer)
+                 {.async, raises: [Defect, LPError]} =
+  ## Mounting filter v2 protocol
+
   info "mounting filter protocol"
-  node.wakuFilter = WakuFilter.new(node.peerManager)
-  node.wakuFilterLegacy = WakuFilterLegacy.new(node.peerManager, node.rng, filterTimeout) #TODO: remove legacy
+  node.wakuFilter = WakuFilter.new(node.peerManager,
+                                   subscriptionTimeout,
+                                   maxFilterPeers,
+                                   maxFilterCriteriaPerPeer)
 
   if node.started:
     await node.wakuFilter.start()
-    await node.wakuFilterLegacy.start() #TODO: remove legacy
 
   node.switch.mount(node.wakuFilter, protocolMatcher(WakuFilterSubscribeCodec))
-  node.switch.mount(node.wakuFilterLegacy, protocolMatcher(WakuLegacyFilterCodec)) #TODO: remove legacy
 
 proc filterHandleMessage*(node: WakuNode,
                           pubsubTopic: PubsubTopic,
diff --git a/waku/utils/tableutils.nim b/waku/utils/tableutils.nim
new file mode 100644
index 000000000..1bdcce941
--- /dev/null
+++ b/waku/utils/tableutils.nim
@@ -0,0 +1,35 @@
+import std/tables,
+       stew/objects,
+       stew/templateutils
+
+template keepItIf*[A, B](tableParam: var Table[A, B], itPredicate: untyped) =
+  bind evalTemplateParamOnce
+  evalTemplateParamOnce(tableParam, t):
+    var itemsToDelete: seq[A]
+    var key {.inject.} : A
+    var val {.inject.} : B
+
+    for k, v in t.mpairs():
+      key = k
+      val = v
+      if not itPredicate:
+        itemsToDelete.add(key)
+
+    for item in itemsToDelete:
+      t.del(item)
+
+template keepItIf*[A, B](tableParam: var TableRef[A, B], itPredicate: untyped) =
+  bind evalTemplateParamOnce
+  evalTemplateParamOnce(tableParam, t):
+    var itemsToDelete: seq[A]
+    let key {.inject.} : A
+    let val {.inject.} : B
+
+    for k, v in t[].mpairs():
+      key = k
+      val = v
+      if not itPredicate:
+        itemsToDelete.add(key)
+
+    for item in itemsToDelete:
+      t[].del(item)
diff --git a/waku/waku_api/rest/admin/handlers.nim b/waku/waku_api/rest/admin/handlers.nim
index 6621908b5..2648c5ee1 100644
--- a/waku/waku_api/rest/admin/handlers.nim
+++ b/waku/waku_api/rest/admin/handlers.nim
@@ -121,9 +121,10 @@ proc installAdminV1GetFilterSubsHandler(router: var RestRouter, node: WakuNode)
       subscriptions: seq[FilterSubscription] = @[]
       filterCriteria: seq[FilterTopic]
 
-    for (peerId, criteria) in node.wakuFilter.subscriptions.pairs():
-      filterCriteria = criteria.toSeq().mapIt(FilterTopic(pubsubTopic: it[0],
-        contentTopic: it[1]))
+    for peerId in node.wakuFilter.subscriptions.peersSubscribed.keys:
+      filterCriteria = node.wakuFilter.subscriptions.getPeerSubscriptions(peerId)
+                                                    .mapIt(FilterTopic(pubsubTopic: it[0],
+                                                                       contentTopic: it[1]))
 
       subscriptions.add(FilterSubscription(peerId: $peerId, filterCriteria: filterCriteria))
 
diff --git a/waku/waku_filter/protocol.nim b/waku/waku_filter/protocol.nim
index 62c0d618a..6ec7ad7fa 100644
--- a/waku/waku_filter/protocol.nim
+++ b/waku/waku_filter/protocol.nim
@@ -22,7 +22,7 @@ logScope:
 const
   WakuLegacyFilterCodec* = "/vac/waku/filter/2.0.0-beta1"
 
-  WakuFilterTimeout: Duration = 2.hours
+  WakuLegacyFilterTimeout*: Duration = 2.hours
 
 
 type WakuFilterResult*[T] = Result[T, string]
@@ -113,7 +113,7 @@ proc initProtocolHandler(wf: WakuFilterLegacy) =
 proc new*(T: type WakuFilterLegacy,
            peerManager: PeerManager,
            rng: ref rand.HmacDrbgContext,
-           timeout: Duration = WakuFilterTimeout): T =
+           timeout: Duration = WakuLegacyFilterTimeout): T =
   let wf = WakuFilterLegacy(rng: rng,
                       peerManager: peerManager,
                       timeout: timeout)
@@ -123,7 +123,7 @@ proc new*(T: type WakuFilterLegacy,
 proc init*(T: type WakuFilterLegacy,
            peerManager: PeerManager,
            rng: ref rand.HmacDrbgContext,
-           timeout: Duration = WakuFilterTimeout): T {.
+           timeout: Duration = WakuLegacyFilterTimeout): T {.
   deprecated: "WakuFilterLegacy.new()' instead".} =
   WakuFilterLegacy.new(peerManager, rng, timeout)
 
diff --git a/waku/waku_filter_v2.nim b/waku/waku_filter_v2.nim
index 7a8984ad6..7f0d7ef23 100644
--- a/waku/waku_filter_v2.nim
+++ b/waku/waku_filter_v2.nim
@@ -1,7 +1,9 @@
 import
   ./waku_filter_v2/common,
-  ./waku_filter_v2/protocol
+  ./waku_filter_v2/protocol,
+  ./waku_filter_v2/subscriptions
 
 export
   common,
-  protocol
+  protocol,
+  subscriptions
diff --git a/waku/waku_filter_v2/protocol.nim b/waku/waku_filter_v2/protocol.nim
index 13824fd11..a0d9d2cdc 100644
--- a/waku/waku_filter_v2/protocol.nim
+++ b/waku/waku_filter_v2/protocol.nim
@@ -25,7 +25,7 @@ logScope:
   topics = "waku filter"
 
 const
-  MaxContentTopicsPerRequest* = 30
+  MaxContentTopicsPerRequest* = 100
 
 type
   WakuFilter* = ref object of LPProtocol
@@ -36,82 +36,69 @@ type
 proc pingSubscriber(wf: WakuFilter, peerId: PeerID): FilterSubscribeResult =
   trace "pinging subscriber", peerId=peerId
 
-  if peerId notin wf.subscriptions:
+  if not wf.subscriptions.isSubscribed(peerId):
     debug "pinging peer has no subscriptions", peerId=peerId
     return err(FilterSubscribeError.notFound())
 
+  wf.subscriptions.refreshSubscription(peerId)
+
   ok()
 
-proc subscribe(wf: WakuFilter, peerId: PeerID, pubsubTopic: Option[PubsubTopic], contentTopics: seq[ContentTopic]): FilterSubscribeResult =
-  if pubsubTopic.isNone() or contentTopics.len() == 0:
+proc subscribe(wf: WakuFilter,
+               peerId: PeerID,
+               pubsubTopic: Option[PubsubTopic],
+               contentTopics: seq[ContentTopic]): FilterSubscribeResult =
+
+  # TODO: check if this condition is valid???
+  if pubsubTopic.isNone() or contentTopics.len == 0:
     return err(FilterSubscribeError.badRequest("pubsubTopic and contentTopics must be specified"))
 
-  if contentTopics.len() > MaxContentTopicsPerRequest:
-    return err(FilterSubscribeError.badRequest("exceeds maximum content topics: " & $MaxContentTopicsPerRequest))
+  if contentTopics.len > MaxContentTopicsPerRequest:
+    return err(FilterSubscribeError.badRequest("exceeds maximum content topics: " &
+                $MaxContentTopicsPerRequest))
 
   let filterCriteria = toHashSet(contentTopics.mapIt((pubsubTopic.get(), it)))
 
   trace "subscribing peer to filter criteria", peerId=peerId, filterCriteria=filterCriteria
 
-  if peerId in wf.subscriptions:
-    # We already have a subscription for this peer. Try to add the new filter criteria.
-    var peerSubscription = wf.subscriptions.mgetOrPut(peerId, initHashSet[FilterCriterion]())
-    if peerSubscription.len() + filterCriteria.len() > MaxCriteriaPerSubscription:
-      return err(FilterSubscribeError.serviceUnavailable("peer has reached maximum number of filter criteria"))
-
-    peerSubscription.incl(filterCriteria)
-    wf.subscriptions[peerId] = peerSubscription
-  else:
-    # We don't have a subscription for this peer yet. Try to add it.
-    if wf.subscriptions.len() >= MaxTotalSubscriptions:
-      return err(FilterSubscribeError.serviceUnavailable("node has reached maximum number of subscriptions"))
-    debug "creating new subscription", peerId=peerId
-    wf.subscriptions[peerId] = filterCriteria
+  wf.subscriptions.addSubscription(peerId, filterCriteria).isOkOr:
+    return err(FilterSubscribeError.serviceUnavailable(error))
 
   ok()
 
-proc unsubscribe(wf: WakuFilter, peerId: PeerID, pubsubTopic: Option[PubsubTopic], contentTopics: seq[ContentTopic]): FilterSubscribeResult =
-  if pubsubTopic.isNone() or contentTopics.len() == 0:
+proc unsubscribe(wf: WakuFilter,
+                 peerId: PeerID,
+                 pubsubTopic: Option[PubsubTopic],
+                 contentTopics: seq[ContentTopic]): FilterSubscribeResult =
+  if pubsubTopic.isNone() or contentTopics.len == 0:
     return err(FilterSubscribeError.badRequest("pubsubTopic and contentTopics must be specified"))
 
-  if contentTopics.len() > MaxContentTopicsPerRequest:
+  if contentTopics.len > MaxContentTopicsPerRequest:
     return err(FilterSubscribeError.badRequest("exceeds maximum content topics: " & $MaxContentTopicsPerRequest))
 
   let filterCriteria = toHashSet(contentTopics.mapIt((pubsubTopic.get(), it)))
 
-  trace "unsubscribing peer from filter criteria", peerId=peerId, filterCriteria=filterCriteria
+  debug "unsubscribing peer from filter criteria", peerId=peerId, filterCriteria=filterCriteria
 
-  if peerId notin wf.subscriptions:
-    debug "unsubscribing peer has no subscriptions", peerId=peerId
+  wf.subscriptions.removeSubscription(peerId, filterCriteria).isOkOr:
     return err(FilterSubscribeError.notFound())
 
-  var peerSubscription = wf.subscriptions.mgetOrPut(peerId, initHashSet[FilterCriterion]())
-
-  if not peerSubscription.containsAny(filterCriteria):
-    debug "unsubscribing peer is not subscribed to any of the content topics in this pubsub topic", peerId=peerId, pubsubTopic=pubsubTopic.get(), contentTopics=contentTopics
-    return err(FilterSubscribeError.notFound())
-
-  peerSubscription.excl(filterCriteria)
-
-  if peerSubscription.len() == 0:
-    debug "peer has no more subscriptions, removing subscription", peerId=peerId
-    wf.subscriptions.del(peerId)
-  else:
-    wf.subscriptions[peerId] = peerSubscription
-
   ok()
 
 proc unsubscribeAll(wf: WakuFilter, peerId: PeerID): FilterSubscribeResult =
-  if peerId notin wf.subscriptions:
+  if not wf.subscriptions.isSubscribed(peerId):
     debug "unsubscribing peer has no subscriptions", peerId=peerId
     return err(FilterSubscribeError.notFound())
 
   debug "removing peer subscription", peerId=peerId
-  wf.subscriptions.del(peerId)
+  wf.subscriptions.removePeer(peerId)
+  wf.subscriptions.cleanUp()
 
   ok()
 
-proc handleSubscribeRequest*(wf: WakuFilter, peerId: PeerId, request: FilterSubscribeRequest): FilterSubscribeResponse =
+proc handleSubscribeRequest*(wf: WakuFilter,
+                             peerId: PeerId,
+                             request: FilterSubscribeRequest): FilterSubscribeResponse =
   info "received filter subscribe request", peerId=peerId, request=request
   waku_filter_requests.inc(labelValues = [$request.filterSubscribeType])
 
@@ -134,7 +121,8 @@ proc handleSubscribeRequest*(wf: WakuFilter, peerId: PeerId, request: FilterSubs
   let
     requestDuration = Moment.now() - requestStartTime
     requestDurationSec = requestDuration.milliseconds.float / 1000  # Duration in seconds with millisecond precision floating point
-  waku_filter_request_duration_seconds.observe(requestDurationSec, labelValues = [$request.filterSubscribeType])
+  waku_filter_request_duration_seconds.observe(
+          requestDurationSec, labelValues = [$request.filterSubscribeType])
 
   if subscribeResult.isErr():
     return FilterSubscribeResponse(
@@ -153,6 +141,7 @@ proc pushToPeer(wf: WakuFilter, peer: PeerId, buffer: seq[byte]) {.async.} =
     trace "no addresses for peer", peer=peer
     return
 
+  ## TODO: Check if dial is necessary always???
   let conn = await wf.peerManager.dialPeer(peer, WakuFilterPushCodec)
   if conn.isNone():
     ## We do not remove this peer, but allow the underlying peer manager
@@ -163,7 +152,10 @@ proc pushToPeer(wf: WakuFilter, peer: PeerId, buffer: seq[byte]) {.async.} =
   await conn.get().writeLp(buffer)
 
 proc pushToPeers(wf: WakuFilter, peers: seq[PeerId], messagePush: MessagePush) {.async.} =
-  debug "pushing message to subscribed peers", pubsubTopic=messagePush.pubsubTopic, contentTopic=messagePush.wakuMessage.contentTopic, peers=peers, hash=messagePush.pubsubTopic.computeMessageHash(messagePush.wakuMessage).to0xHex()
+  debug "pushing message to subscribed peers", pubsubTopic=messagePush.pubsubTopic,
+          contentTopic=messagePush.wakuMessage.contentTopic,
+          peers=peers,
+          hash=messagePush.pubsubTopic.computeMessageHash(messagePush.wakuMessage).to0xHex()
 
   let bufferToPublish = messagePush.encode().buffer
 
@@ -179,18 +171,18 @@ proc maintainSubscriptions*(wf: WakuFilter) =
 
   ## Remove subscriptions for peers that have been removed from peer store
   var peersToRemove: seq[PeerId]
-  for peerId, peerSubscription in wf.subscriptions.pairs():
-    ## TODO: currently we only maintain by syncing with peer store. We could
-    ## consider other metrics, such as subscription age, activity, etc.
+  for peerId in wf.subscriptions.peersSubscribed.keys:
     if not wf.peerManager.peerStore.hasPeer(peerId, WakuFilterPushCodec):
       debug "peer has been removed from peer store, removing subscription", peerId=peerId
       peersToRemove.add(peerId)
 
-  if peersToRemove.len() > 0:
+  if peersToRemove.len > 0:
     wf.subscriptions.removePeers(peersToRemove)
 
+  wf.subscriptions.cleanUp()
+
   ## Periodic report of number of subscriptions
-  waku_filter_subscriptions.set(wf.subscriptions.len().float64)
+  waku_filter_subscriptions.set(wf.subscriptions.peersSubscribed.len.float64)
 
 const MessagePushTimeout = 20.seconds
 proc handleMessage*(wf: WakuFilter, pubsubTopic: PubsubTopic, message: WakuMessage) {.async.} =
@@ -201,7 +193,7 @@ proc handleMessage*(wf: WakuFilter, pubsubTopic: PubsubTopic, message: WakuMessa
   block:
     ## Find subscribers and push message to them
     let subscribedPeers = wf.subscriptions.findSubscribedPeers(pubsubTopic, message.contentTopic)
-    if subscribedPeers.len() == 0:
+    if subscribedPeers.len == 0:
       trace "no subscribed peers found", pubsubTopic=pubsubTopic, contentTopic=message.contentTopic
       return
 
@@ -210,11 +202,15 @@ proc handleMessage*(wf: WakuFilter, pubsubTopic: PubsubTopic, message: WakuMessa
           wakuMessage: message)
 
     if not await wf.pushToPeers(subscribedPeers, messagePush).withTimeout(MessagePushTimeout):
-      debug "timed out pushing message to peers", pubsubTopic=pubsubTopic, contentTopic=message.contentTopic, hash=pubsubTopic.computeMessageHash(message).to0xHex()
+      debug "timed out pushing message to peers", pubsubTopic=pubsubTopic,
+                                                  contentTopic=message.contentTopic,
+                                                  hash=pubsubTopic.computeMessageHash(message).to0xHex()
       waku_filter_errors.inc(labelValues = [pushTimeoutFailure])
     else:
-      debug "pushed message succesfully to all subscribers", pubsubTopic=pubsubTopic, contentTopic=message.contentTopic, hash=pubsubTopic.computeMessageHash(message).to0xHex()
-
+      debug "pushed message succesfully to all subscribers",
+              pubsubTopic=pubsubTopic,
+              contentTopic=message.contentTopic,
+              hash=pubsubTopic.computeMessageHash(message).to0xHex()
 
   let
     handleMessageDuration = Moment.now() - handleMessageStartTime
@@ -247,13 +243,21 @@ proc initProtocolHandler(wf: WakuFilter) =
   wf.codec = WakuFilterSubscribeCodec
 
 proc new*(T: type WakuFilter,
-          peerManager: PeerManager): T =
+          peerManager: PeerManager,
+          subscriptionTimeout: Duration = DefaultSubscriptionTimeToLiveSec,
+          maxFilterPeers: uint32 = MaxFilterPeers,
+          maxFilterCriteriaPerPeer: uint32 = MaxFilterCriteriaPerPeer): T =
 
   let wf = WakuFilter(
+    subscriptions: FilterSubscriptions.init(subscriptionTimeout,
+                                            maxFilterPeers,
+                                            maxFilterCriteriaPerPeer
+                                           ),
     peerManager: peerManager
   )
+
   wf.initProtocolHandler()
-  wf
+  return wf
 
 const MaintainSubscriptionsInterval* = 1.minutes
 
@@ -278,4 +282,5 @@ method stop*(wf: WakuFilter) {.async.} =
   debug "stopping filter protocol"
   if not wf.maintenanceTask.isNil():
     wf.maintenanceTask.clearTimer()
+
   await procCall LPProtocol(wf).stop()
diff --git a/waku/waku_filter_v2/subscriptions.nim b/waku/waku_filter_v2/subscriptions.nim
index bd248f54c..ba568f331 100644
--- a/waku/waku_filter_v2/subscriptions.nim
+++ b/waku/waku_filter_v2/subscriptions.nim
@@ -6,48 +6,163 @@ else:
 import
   std/[sets,tables],
   chronicles,
-  libp2p/peerid
+  chronos,
+  libp2p/peerid,
+  stew/shims/sets
 import
-  ../waku_core
+  ../waku_core,
+  ../utils/tableutils
 
 logScope:
   topics = "waku filter subscriptions"
 
 const
-  MaxTotalSubscriptions* = 1000 # TODO make configurable
-  MaxCriteriaPerSubscription* = 1000
+  MaxFilterPeers* = 1000
+  MaxFilterCriteriaPerPeer* = 1000
+  DefaultSubscriptionTimeToLiveSec* = 5.minutes
 
 type
-  FilterCriterion* = (PubsubTopic, ContentTopic) # a single filter criterion is fully defined by a pubsub topic and content topic
+  # a single filter criterion is fully defined by a pubsub topic and content topic
+  FilterCriterion* = tuple
+    pubsubTopic: PubsubTopic
+    contentTopic: ContentTopic
+
   FilterCriteria* = HashSet[FilterCriterion] # a sequence of filter criteria
-  FilterSubscriptions* = Table[PeerID, FilterCriteria] # a mapping of peer ids to a sequence of filter criteria
 
-proc findSubscribedPeers*(subscriptions: FilterSubscriptions, pubsubTopic: PubsubTopic, contentTopic: ContentTopic): seq[PeerID] =
-  ## Find all peers subscribed to a given topic and content topic
-  let filterCriterion = (pubsubTopic, contentTopic)
+  SubscribedPeers* = HashSet[PeerID] # a sequence of peer ids
 
-  var subscribedPeers: seq[PeerID]
+  PeerData* = tuple
+    lastSeen: Moment
+    criteriaCount: uint
 
-  # TODO: for large maps, this can be optimized using a reverse index
-  for (peerId, criteria) in subscriptions.pairs():
-    if filterCriterion in criteria:
-      subscribedPeers.add(peerId)
+  FilterSubscriptions* = object
+    peersSubscribed*    : Table[PeerID, PeerData]
+    subscriptions       : Table[FilterCriterion, SubscribedPeers]
+    subscriptionTimeout : Duration
+    maxPeers            : uint
+    maxCriteriaPerPeer  : uint
 
-  subscribedPeers
+proc init*(T: type FilterSubscriptions,
+          subscriptionTimeout: Duration = DefaultSubscriptionTimeToLiveSec,
+          maxFilterPeers: uint32 = MaxFilterPeers,
+          maxFilterCriteriaPerPeer: uint32 = MaxFilterCriteriaPerPeer): FilterSubscriptions =
+  ## Create a new filter subscription object
+  return FilterSubscriptions(
+              peersSubscribed: initTable[PeerID, PeerData](),
+              subscriptions: initTable[FilterCriterion, SubscribedPeers](),
+              subscriptionTimeout: subscriptionTimeout,
+              maxPeers: maxFilterPeers,
+              maxCriteriaPerPeer: maxFilterCriteriaPerPeer
+            )
 
-proc removePeer*(subscriptions: var FilterSubscriptions, peerId: PeerID) =
+proc isSubscribed*(s: var FilterSubscriptions, peerId: PeerID): bool =
+  s.peersSubscribed.withValue(peerId, data):
+    return Moment.now() - data.lastSeen <= s.subscriptionTimeout
+
+  return false
+
+proc subscribedPeerCount*(s: FilterSubscriptions): uint =
+  return cast[uint](s.peersSubscribed.len)
+
+proc getPeerSubscriptions*(s: var FilterSubscriptions, peerId: PeerID): seq[FilterCriterion] =
+  ## Get all pubsub-content topics a peer is subscribed to
+  var subscribedContentTopics: seq[FilterCriterion] = @[]
+  s.peersSubscribed.withValue(peerId, data):
+    if data.criteriaCount == 0:
+      return subscribedContentTopics
+
+    for filterCriterion, subscribedPeers in s.subscriptions.mpairs:
+      if peerId in subscribedPeers:
+        subscribedContentTopics.add(filterCriterion)
+
+  return subscribedContentTopics
+
+proc findSubscribedPeers*(s: var FilterSubscriptions, pubsubTopic: PubsubTopic, contentTopic: ContentTopic): seq[PeerID] =
+  let filterCriterion : FilterCriterion = (pubsubTopic, contentTopic)
+
+  var foundPeers : seq[PeerID] = @[]
+  # only peers subscribed to criteria and with legit subscription is counted
+  s.subscriptions.withValue(filterCriterion, peers):
+    for peer in peers[]:
+      if s.isSubscribed(peer):
+        foundPeers.add(peer)
+
+  return foundPeers
+
+proc removePeer*(s: var FilterSubscriptions, peerId: PeerID) =
   ## Remove all subscriptions for a given peer
-  subscriptions.del(peerId)
+  s.peersSubscribed.del(peerId)
 
-proc removePeers*(subscriptions: var FilterSubscriptions, peerIds: seq[PeerID]) =
+proc removePeers*(s: var FilterSubscriptions, peerIds: seq[PeerID]) =
   ## Remove all subscriptions for a given list of peers
-  for peerId in peerIds:
-    subscriptions.removePeer(peerId)
+  s.peersSubscribed.keepItIf(key notin peerIds)
+
+proc cleanUp*(fs: var FilterSubscriptions) =
+  ## Remove all subscriptions for peers that have not been seen for a while
+  let now = Moment.now()
+  fs.peersSubscribed.keepItIf(now - val.lastSeen <= fs.subscriptionTimeout)
+
+  var filtersToRemove: seq[FilterCriterion] = @[]
+  for filterCriterion, subscribedPeers in fs.subscriptions.mpairs:
+    subscribedPeers.keepItIf(fs.isSubscribed(it)==true)
+
+  fs.subscriptions.keepItIf(val.len > 0)
+
+proc refreshSubscription*(s: var FilterSubscriptions, peerId: PeerID) =
+  s.peersSubscribed.withValue(peerId, data):
+    data.lastSeen = Moment.now()
+
+proc addSubscription*(s: var FilterSubscriptions, peerId: PeerID, filterCriteria: FilterCriteria): Result[void, string] =
+  ## Add a subscription for a given peer
+  var peerData: ptr PeerData
+
+  s.peersSubscribed.withValue(peerId, data):
+    if data.criteriaCount + cast[uint](filterCriteria.len) > s.maxCriteriaPerPeer:
+      return err("peer has reached maximum number of filter criteria")
+
+    data.lastSeen = Moment.now()
+    peerData = data
+
+  do:
+    ## not yet subscribed
+    if cast[uint](s.peersSubscribed.len) >= s.maxPeers:
+      return err("node has reached maximum number of subscriptions")
+
+    let newPeerData: PeerData = (lastSeen: Moment.now(), criteriaCount: 0)
+    peerData = addr(s.peersSubscribed.mgetOrPut(peerId, newPeerData))
+
+  for filterCriterion in filterCriteria:
+    var peersOfSub = addr(s.subscriptions.mgetOrPut(filterCriterion, SubscribedPeers()))
+    if peerId notin peersOfSub[]:
+      peersOfSub[].incl(peerId)
+      peerData.criteriaCount += 1
+
+  return ok()
+
+proc removeSubscription*(s: var FilterSubscriptions,
+                        peerId: PeerID,
+                        filterCriteria: FilterCriteria):
+                  Result[void, string] =
+  ## Remove a subscription for a given peer
+
+  s.peersSubscribed.withValue(peerId, peerData):
+    peerData.lastSeen = Moment.now()
+    for filterCriterion in filterCriteria:
+      s.subscriptions.withValue(filterCriterion, peers):
+        if peers[].missingOrexcl(peerId) == false:
+          peerData.criteriaCount -= 1
+
+          if peers[].len == 0:
+            s.subscriptions.del(filterCriterion)
+          if peerData.criteriaCount == 0:
+            s.peersSubscribed.del(peerId)
+      do:
+        ## Maybe let just run through and log it as a warning
+        return err("Peer was not subscribed to criterion")
+
+    return ok()
+
+  do:
+    return err("Peer has no subscriptions")
+
 
-proc containsAny*(criteria: FilterCriteria, otherCriteria: FilterCriteria): bool =
-  ## Check if a given pubsub topic is contained in a set of filter criteria
-  ## TODO: Better way to achieve this?
-  for criterion in otherCriteria:
-    if criterion in criteria:
-      return true
-  false