@libp2p/interface-compliance-tests 1.1.22 → 1.1.23

package/src/pubsub/connection-handlers.ts

@@ -6,7 +6,6 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
-import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { Message } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
@@ -74,10 +73,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       it('existing subscriptions are sent upon peer connection', async function () {
         const subscriptionsChanged = Promise.all([
-          new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
+          new Promise((resolve) => psA.addEventListener('subscription-change', resolve, {
             once: true
           })),
-          new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
+          new Promise((resolve) => psB.addEventListener('subscription-change', resolve, {
             once: true
           }))
         ])
@@ -174,10 +173,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          defer.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            defer.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -189,7 +191,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer.promise
       })
@@ -275,10 +277,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          defer.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            defer.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -290,7 +295,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer.promise
       })
@@ -357,11 +362,14 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let subscribedTopics = psA.getTopics()
         expect(subscribedTopics).to.not.include(topic)
 
-        psA.addEventListener(topic, (evt) => {
-          const msg = evt.detail
-          expect(msg.data).to.equalBytes(data)
-          counter++
-          counter === 1 ? defer1.resolve() : defer2.resolve()
+        psA.subscribe(topic)
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            const msg = evt.detail
+            expect(msg.data).to.equalBytes(data)
+            counter++
+            counter === 1 ? defer1.resolve() : defer2.resolve()
+          }
         })
         psA.subscribe(topic)
 
@@ -373,7 +381,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer1.promise
 
@@ -406,7 +414,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           return subscribedPeers.toString().includes(peerA.toString())
         })
 
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        psB.publish(topic, data)
 
         await defer2.promise
       })
@@ -417,8 +425,13 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         let aReceivedSecondMessageFromB = false
         let bReceivedFirstMessageFromA = false
         let bReceivedSecondMessageFromA = false
+        const topic = 'reconnect-channel'
 
         const handlerSpyA = (evt: CustomEvent<Message>) => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
           const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
@@ -431,6 +444,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           }
         }
         const handlerSpyB = (evt: CustomEvent<Message>) => {
+          if (evt.detail.topic !== topic) {
+            return
+          }
+
           const message = evt.detail
           const data = uint8ArrayToString(message.data)
 
@@ -443,10 +460,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           }
         }
 
-        const topic = 'reconnect-channel'
-
-        psA.addEventListener(topic, handlerSpyA)
-        psB.addEventListener(topic, handlerSpyB)
+        psA.addEventListener('message', handlerSpyA)
+        psB.addEventListener('message', handlerSpyB)
         psA.subscribe(topic)
         psB.subscribe(topic)
 
@@ -470,8 +485,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         })
 
         // Verify messages go both ways
-        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
+        psA.publish(topic, uint8ArrayFromString('message-from-a-1'))
+        psB.publish(topic, uint8ArrayFromString('message-from-b-1'))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -484,8 +499,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
-        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
+        psA.publish(topic, uint8ArrayFromString('message-from-a-2'))
+        psB.publish(topic, uint8ArrayFromString('message-from-b-2'))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })

package/src/pubsub/emit-self.ts

@@ -3,7 +3,6 @@ import sinon from 'sinon'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { mockRegistrar } from '../mocks/registrar.js'
-import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { PubSubArgs } from './index.js'
 import type { PubSubBaseProtocol } from '@libp2p/pubsub'
@@ -43,11 +42,17 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       it('should emit to self on publish', async () => {
-        const promise = new Promise((resolve) => pubsub.addEventListener(topic, resolve, {
-          once: true
-        }))
+        const promise = new Promise<void>((resolve) => {
+          pubsub.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              resolve()
+            }
+          }, {
+            once: true
+          })
+        })
 
-        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        pubsub.publish(topic, data)
 
         return await promise
       })
@@ -78,11 +83,11 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       })
 
       it('should not emit to self on publish', async () => {
-        pubsub.addEventListener(topic, () => shouldNotHappen, {
+        pubsub.addEventListener('message', shouldNotHappen, {
           once: true
         })
 
-        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+        pubsub.publish(topic, data)
 
         // Wait 1 second to guarantee that self is not noticed
         return await new Promise((resolve) => setTimeout(resolve, 1000))

package/src/pubsub/messages.ts

@@ -8,7 +8,6 @@ import { mockRegistrar } from '../mocks/registrar.js'
 import pDefer from 'p-defer'
 import delay from 'delay'
 import pWaitFor from 'p-wait-for'
-import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
 import type { PubSubRPC } from '@libp2p/interfaces/pubsub'
 import type { PubSubArgs } from './index.js'
@@ -52,7 +51,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       const spy = sinon.spy(pubsub, 'publishMessage')
 
-      await pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
+      await pubsub.publish(topic, data)
 
       await pWaitFor(async () => {
         return spy.callCount === 1
@@ -120,8 +119,10 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       const deferred = pDefer()
 
-      pubsub.addEventListener(topic, () => {
-        deferred.resolve()
+      pubsub.addEventListener('message', (evt) => {
+        if (evt.detail.topic === topic) {
+          deferred.resolve()
+        }
       })
 
       await pubsub.processRpc(peerStream.id, peerStream, rpc)

package/src/pubsub/multiple-nodes.ts

@@ -7,7 +7,6 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
-import { CustomEvent } from '@libp2p/interfaces'
 import { waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
 import type { Message } from '@libp2p/interfaces/pubsub'
@@ -149,7 +148,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
           psC.subscribe(topic)
           expect(psC.getTopics()).to.deep.equal([topic])
 
-          psB.addEventListener('pubsub:subscription-change', () => {
+          psB.addEventListener('subscription-change', () => {
             expect(psA.getPeers().length).to.equal(1)
             expect(psB.getPeers().length).to.equal(2)
             expect(psB.getSubscribers(topic).map(p => p.toString())).to.deep.equal([peerIdC.toString()])
@@ -172,9 +171,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           let counter = 0
 
-          psA.addEventListener(topic, incMsg)
-          psB.addEventListener(topic, incMsg)
-          psC.addEventListener(topic, incMsg)
+          psA.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psB.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psC.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
 
           await Promise.all([
             waitForSubscriptionUpdate(psA, psB),
@@ -182,7 +193,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             waitForSubscriptionUpdate(psC, psB)
           ])
 
-          void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+          psA.publish(topic, uint8ArrayFromString('hey'))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -192,9 +203,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
           function check () {
             if (++counter === 3) {
-              psA.removeEventListener(topic, incMsg)
-              psB.removeEventListener(topic, incMsg)
-              psC.removeEventListener(topic, incMsg)
+              psA.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
+              psB.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
+              psC.removeEventListener('message', (evt) => {
+                if (evt.detail.topic === topic) {
+                  incMsg(evt)
+                }
+              })
               defer.resolve()
             }
           }
@@ -216,34 +239,33 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             const defer = pDefer()
             let counter = 0
 
+            psA.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+            psB.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+            psC.addEventListener('message', (evt) => {
+              if (evt.detail.topic === topic) {
+                incMsg(evt)
+              }
+            })
+
             psA.subscribe(topic)
             psB.subscribe(topic)
             psC.subscribe(topic)
 
-            // await subscription change
-            await Promise.all([
-              new Promise(resolve => psA.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              })),
-              new Promise(resolve => psB.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              })),
-              new Promise(resolve => psC.addEventListener('pubsub:subscription-change', () => resolve(null), {
-                once: true
-              }))
-            ])
-
-            psA.addEventListener(topic, incMsg)
-            psB.addEventListener(topic, incMsg)
-            psC.addEventListener(topic, incMsg)
-
             await Promise.all([
               waitForSubscriptionUpdate(psA, psB),
               waitForSubscriptionUpdate(psB, psA),
               waitForSubscriptionUpdate(psC, psB)
             ])
 
-            void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+            psB.publish(topic, uint8ArrayFromString('hey'))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -253,9 +275,21 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
             function check () {
               if (++counter === 3) {
-                psA.removeEventListener(topic, incMsg)
-                psB.removeEventListener(topic, incMsg)
-                psC.removeEventListener(topic, incMsg)
+                psA.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
+                psB.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
+                psC.removeEventListener('message', (evt) => {
+                  if (evt.detail.topic === topic) {
+                    incMsg(evt)
+                  }
+                })
                 defer.resolve()
               }
             }
@@ -415,17 +449,38 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         it('publishes from c', async function () {
           const defer = pDefer()
           let counter = 0
+          const topic = 'Z'
 
-          psA.subscribe('Z')
-          psA.addEventListener('Z', incMsg)
-          psB.subscribe('Z')
-          psB.addEventListener('Z', incMsg)
-          psC.subscribe('Z')
-          psC.addEventListener('Z', incMsg)
-          psD.subscribe('Z')
-          psD.addEventListener('Z', incMsg)
-          psE.subscribe('Z')
-          psE.addEventListener('Z', incMsg)
+          psA.subscribe(topic)
+          psA.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psB.subscribe(topic)
+          psB.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psC.subscribe(topic)
+          psC.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psD.subscribe(topic)
+          psD.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
+          psE.subscribe(topic)
+          psE.addEventListener('message', (evt) => {
+            if (evt.detail.topic === topic) {
+              incMsg(evt)
+            }
+          })
 
           await Promise.all([
             waitForSubscriptionUpdate(psA, psB),
@@ -435,7 +490,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
             waitForSubscriptionUpdate(psE, psD)
           ])
 
-          void psC.dispatchEvent(new CustomEvent<Uint8Array>('Z', { detail: uint8ArrayFromString('hey from c') }))
+          psC.publish('Z', uint8ArrayFromString('hey from c'))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail

package/src/pubsub/two-nodes.ts

@@ -7,7 +7,6 @@ import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
-import { CustomEvent } from '@libp2p/interfaces'
 import { waitForSubscriptionUpdate } from './utils.js'
 import type { TestSetup } from '../index.js'
 import type { Message } from '@libp2p/interfaces/pubsub'
@@ -89,7 +88,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Subscribe to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psB.addEventListener('pubsub:subscription-change', (evt) => {
+      psB.addEventListener('subscription-change', (evt) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
         expect(psA.getTopics()).to.deep.equal([topic])
         expect(psB.getPeers()).to.have.lengthOf(1)
@@ -110,25 +109,26 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Publish to a topic in nodeA', async () => {
       const defer = pDefer()
 
-      psA.addEventListener(topic, (evt) => {
-        const msg = evt.detail
-        expect(uint8ArrayToString(msg.data)).to.equal('hey')
-        psB.removeEventListener(topic, shouldNotHappen)
-        defer.resolve()
+      psA.addEventListener('message', (evt) => {
+        if (evt.detail.topic === topic) {
+          const msg = evt.detail
+          expect(uint8ArrayToString(msg.data)).to.equal('hey')
+          psB.removeEventListener('message', shouldNotHappen)
+          defer.resolve()
+        }
       }, {
         once: true
       })
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
+      psA.subscribe(topic)
+      psB.subscribe(topic)
 
       await Promise.all([
         waitForSubscriptionUpdate(psA, psB),
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
+      psA.publish(topic, uint8ArrayFromString('hey'))
 
       return await defer.promise
     })
@@ -136,16 +136,24 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
     it('Publish to a topic in nodeB', async () => {
       const defer = pDefer()
 
-      psA.addEventListener(topic, (evt) => {
+      psA.addEventListener('message', (evt) => {
+        if (evt.detail.topic !== topic) {
+          return
+        }
+
         const msg = evt.detail
-        psA.addEventListener(topic, shouldNotHappen, {
+        psA.addEventListener('message', (evt) => {
+          if (evt.detail.topic === topic) {
+            shouldNotHappen()
+          }
+        }, {
           once: true
         })
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
 
         setTimeout(() => {
-          psA.removeEventListener(topic, shouldNotHappen)
-          psB.removeEventListener(topic, shouldNotHappen)
+          psA.removeEventListener('message')
+          psB.removeEventListener('message')
 
           defer.resolve()
         }, 100)
@@ -153,16 +161,17 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         once: true
       })
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
+      psB.addEventListener('message', shouldNotHappen)
+
+      psA.subscribe(topic)
+      psB.subscribe(topic)
 
       await Promise.all([
         waitForSubscriptionUpdate(psA, psB),
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
+      psB.publish(topic, uint8ArrayFromString('banana'))
 
       return await defer.promise
     })
@@ -171,10 +180,8 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       const defer = pDefer()
       let counter = 0
 
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-      psA.addEventListener(topic, receivedMsg)
+      psB.addEventListener('message', shouldNotHappen)
+      psA.addEventListener('message', receivedMsg)
 
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
@@ -184,19 +191,22 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
         expect(msg.topic).to.be.equal(topic)
 
         if (++counter === 10) {
-          psA.removeEventListener(topic, receivedMsg)
-          psB.removeEventListener(topic, shouldNotHappen)
+          psA.removeEventListener('message', receivedMsg)
+          psB.removeEventListener('message', shouldNotHappen)
 
           defer.resolve()
         }
       }
 
+      psA.subscribe(topic)
+      psB.subscribe(topic)
+
       await Promise.all([
         waitForSubscriptionUpdate(psA, psB),
         waitForSubscriptionUpdate(psB, psA)
       ])
 
-      Array.from({ length: 10 }, (_, i) => psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') })))
+      Array.from({ length: 10 }, (_, i) => psB.publish(topic, uint8ArrayFromString('banana')))
 
       return await defer.promise
     })
@@ -205,7 +215,7 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
       const defer = pDefer()
       let callCount = 0
 
-      psB.addEventListener('pubsub:subscription-change', (evt) => {
+      psB.addEventListener('subscription-change', (evt) => {
         callCount++
 
         if (callCount === 1) {
@@ -239,33 +249,5 @@ export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
 
       return await defer.promise
     })
-
-    it.skip('Publish to a topic:Z in nodeA nodeB', async () => {
-      const defer = pDefer()
-      const topic = 'Z'
-
-      psA.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-      psB.addEventListener(topic, shouldNotHappen, {
-        once: true
-      })
-
-      await Promise.all([
-        waitForSubscriptionUpdate(psA, psB),
-        waitForSubscriptionUpdate(psB, psA)
-      ])
-
-      setTimeout(() => {
-        psA.removeEventListener(topic, shouldNotHappen)
-        psB.removeEventListener(topic, shouldNotHappen)
-        defer.resolve()
-      }, 100)
-
-      void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
-      void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('banana') }))
-
-      return await defer.promise
-    })
   })
 }

package/src/pubsub/utils.ts

@@ -5,7 +5,7 @@ import type { PubSubBaseProtocol } from '@libp2p/pubsub'
 
 export async function waitForSubscriptionUpdate (a: PubSubBaseProtocol, b: PubSubBaseProtocol) {
   await pWaitFor(async () => {
-    const event = await pEvent<'pubsub:subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'pubsub:subscription-change')
+    const event = await pEvent<'subscription-change', CustomEvent<SubscriptionChangeData>>(a, 'subscription-change')
 
     return event.detail.peerId.equals(b.components.getPeerId())
   })