@libp2p/interface-compliance-tests 1.1.15 → 1.1.18

package/src/pubsub/api.ts

@@ -8,17 +8,18 @@ import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import delay from 'delay'
 import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSub, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSubArgs } from './index.js'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('pubsub api', () => {
-    let pubsub: PubSub<EventMap>
+    let pubsub: PubSub
     let registrar: Registrar
 
     // Create pubsub router
@@ -26,9 +27,13 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
       registrar = mockRegistrar()
 
       pubsub = await common.setup({
-        peerId: await createEd25519PeerId(),
-        registrar,
-        emitSelf: true
+        components: new Components({
+          peerId: await createEd25519PeerId(),
+          registrar
+        }),
+        init: {
+          emitSelf: true
+        }
       })
     })
 
@@ -75,7 +80,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
       await pWaitFor(() => pubsub.getTopics().length === 0)
 
       // Publish to guarantee the handler is not called
-      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
       // handlers are called async
       await delay(100)
@@ -93,7 +98,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         expect(msg).to.not.eql(undefined)
         defer.resolve()
       })
-      pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
       await defer.promise
 
       await pubsub.stop()

package/src/pubsub/connection-handlers.ts

@@ -8,16 +8,17 @@ 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, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
-
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+import type { Message } from '@libp2p/interfaces/pubsub'
+import type { PubSubArgs } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('pubsub connection handlers', () => {
-    let psA: PubsubBaseProtocol<EventMap>
-    let psB: PubsubBaseProtocol<EventMap>
+    let psA: PubSubBaseProtocol
+    let psB: PubSubBaseProtocol
     let peerA: PeerId
     let peerB: PeerId
     let registrarA: Registrar
@@ -33,12 +34,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         // Start pubsub
@@ -97,8 +104,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
     })
 
     describe('pubsub started before connect', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol
+      let psB: PubSubBaseProtocol
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -113,12 +120,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         await psA.start()
@@ -177,15 +190,15 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub started after connect', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol
+      let psB: PubSubBaseProtocol
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -200,12 +213,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
       })
 
@@ -275,15 +294,15 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer.promise
       })
     })
 
     describe('pubsub with intermittent connections', () => {
-      let psA: PubsubBaseProtocol<EventMap>
-      let psB: PubsubBaseProtocol<EventMap>
+      let psA: PubSubBaseProtocol
+      let psB: PubSubBaseProtocol
       let peerA: PeerId
       let peerB: PeerId
       let registrarA: Registrar
@@ -298,12 +317,18 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         registrarB = mockRegistrar()
 
         psA = await common.setup({
-          peerId: peerA,
-          registrar: registrarA
+          components: new Components({
+            peerId: peerA,
+            registrar: registrarA
+          }),
+          init: {}
         })
         psB = await common.setup({
-          peerId: peerB,
-          registrar: registrarB
+          components: new Components({
+            peerId: peerB,
+            registrar: registrarB
+          }),
+          init: {}
         })
 
         await psA.start()
@@ -354,7 +379,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           const subscribedPeers = psB.getSubscribers(topic)
           return subscribedPeers.map(p => p.toString()).includes(peerA.toString())
         })
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer1.promise
 
@@ -387,7 +412,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           return subscribedPeers.toString().includes(peerA.toString())
         })
 
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         await defer2.promise
       })
@@ -451,8 +476,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         })
 
         // Verify messages go both ways
-        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-1') }))
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-1') }))
+        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') }))
         await pWaitFor(() => {
           return aReceivedFirstMessageFromB && bReceivedFirstMessageFromA
         })
@@ -465,8 +490,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         await pWaitFor(() => psAConnUpdateSpy.callCount === 1)
 
         // Verify messages go both ways after the disconnect
-        void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-a-2') }))
-        void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('message-from-b-2') }))
+        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') }))
         await pWaitFor(() => {
           return aReceivedSecondMessageFromB && bReceivedSecondMessageFromA
         })

package/src/pubsub/emit-self.ts

@@ -5,24 +5,28 @@ 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 { PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSubArgs } from './index.js'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 const shouldNotHappen = () => expect.fail()
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('emit self', () => {
-    let pubsub: PubsubBaseProtocol<EventMap>
+    let pubsub: PubSubBaseProtocol
 
     describe('enabled', () => {
       before(async () => {
         pubsub = await common.setup({
-          peerId: await createEd25519PeerId(),
-          registrar: mockRegistrar(),
-          emitSelf: true
+          components: new Components({
+            peerId: await createEd25519PeerId(),
+            registrar: mockRegistrar()
+          }),
+          init: {
+            emitSelf: true
+          }
         })
       })
 
@@ -42,7 +46,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           once: true
         }))
 
-        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         return await promise
       })
@@ -51,9 +55,13 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
     describe('disabled', () => {
       before(async () => {
         pubsub = await common.setup({
-          peerId: await createEd25519PeerId(),
-          registrar: mockRegistrar(),
-          emitSelf: false
+          components: new Components({
+            peerId: await createEd25519PeerId(),
+            registrar: mockRegistrar()
+          }),
+          init: {
+            emitSelf: false
+          }
         })
       })
 
@@ -73,7 +81,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           once: true
         })
 
-        void pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+        void pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
         // Wait 1 second to guarantee that self is not noticed
         return await new Promise((resolve) => setTimeout(resolve, 1000))

package/src/pubsub/index.ts

@@ -5,20 +5,16 @@ import connectionHandlersTest from './connection-handlers.js'
 import twoNodesTest from './two-nodes.js'
 import multipleNodesTest from './multiple-nodes.js'
 import type { TestSetup } from '../index.js'
-import type { Message, PubSubEvents, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSubInit } from '@libp2p/interfaces/pubsub'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import type { Components } from '@libp2p/interfaces/components'
 
-export interface EventMap extends PubSubEvents {
-  'topic': CustomEvent<Message>
-  'foo': CustomEvent<Message>
-  'test-topic': CustomEvent<Message>
-  'reconnect-channel': CustomEvent<Message>
-  'Z': CustomEvent<Message>
-  'Za': CustomEvent<Message>
-  'Zb': CustomEvent<Message>
+export interface PubSubArgs {
+  components: Components
+  init: PubSubInit
 }
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('interface-pubsub compliance tests', () => {
     apiTest(common)
     emitSelfTest(common)

package/src/pubsub/messages.ts

@@ -10,23 +10,32 @@ import delay from 'delay'
 import pWaitFor from 'p-wait-for'
 import { CustomEvent } from '@libp2p/interfaces'
 import type { TestSetup } from '../index.js'
-import type { PubSubOptions, RPC } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
+import type { PubSubRPC } from '@libp2p/interfaces/pubsub'
+import type { PubSubArgs } from './index.js'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('messages', () => {
-    let pubsub: PubsubBaseProtocol<EventMap>
+    let peerId: PeerId
+    let pubsub: PubSubBaseProtocol
 
     // Create pubsub router
     beforeEach(async () => {
+      peerId = await createEd25519PeerId()
+
       pubsub = await common.setup({
-        peerId: await createEd25519PeerId(),
-        registrar: mockRegistrar(),
-        emitSelf: true
+        components: new Components({
+          peerId,
+          registrar: mockRegistrar()
+        }),
+        init: {
+          emitSelf: true
+        }
       })
       await pubsub.start()
     })
@@ -42,7 +51,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
 
       const spy = sinon.spy(pubsub, 'publishMessage')
 
-      await pubsub.dispatchEvent(new CustomEvent(topic, { detail: data }))
+      await pubsub.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: data }))
 
       await pWaitFor(async () => {
         return spy.callCount === 1
@@ -52,8 +61,8 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
 
       const [from, messageToEmit] = spy.getCall(0).args
 
-      expect(from.toString()).to.equal(pubsub.peerId.toString())
-      expect(messageToEmit.seqno).to.not.eql(undefined)
+      expect(from.toString()).to.equal(peerId.toString())
+      expect(messageToEmit.sequenceNumber).to.not.eql(undefined)
       expect(messageToEmit.key).to.not.eql(undefined)
       expect(messageToEmit.signature).to.not.eql(undefined)
     })
@@ -66,12 +75,12 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         id: await createEd25519PeerId(),
         protocol: 'test'
       })
-      const rpc: RPC = {
+      const rpc: PubSubRPC = {
         subscriptions: [],
         messages: [{
           from: peerStream.id.toBytes(),
           data,
-          seqno: await noSignMsgId(data),
+          sequenceNumber: await noSignMsgId(data),
           topic: topic
         }]
       }
@@ -97,7 +106,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         protocol: 'test'
       })
 
-      const rpc: RPC = {
+      const rpc: PubSubRPC = {
         subscriptions: [],
         messages: [{
           from: peerStream.id.toBytes(),

package/src/pubsub/multiple-nodes.ts

@@ -10,22 +10,23 @@ 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, PubSubOptions } from '@libp2p/interfaces/pubsub'
-import type { EventMap } from './index.js'
-import type { PeerId } from '@libp2p/interfaces/src/peer-id'
-import type { Registrar } from '@libp2p/interfaces/src/registrar'
-import type { PubsubBaseProtocol } from '@libp2p/pubsub'
-
-export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>) => {
+import type { Message } from '@libp2p/interfaces/pubsub'
+import type { PubSubArgs } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Registrar } from '@libp2p/interfaces/registrar'
+import type { PubSubBaseProtocol } from '@libp2p/pubsub'
+import { Components } from '@libp2p/interfaces/components'
+
+export default (common: TestSetup<PubSubBaseProtocol, PubSubArgs>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
         // line
         // ◉────◉────◉
         // a    b    c
-        let psA: PubsubBaseProtocol<EventMap>
-        let psB: PubsubBaseProtocol<EventMap>
-        let psC: PubsubBaseProtocol<EventMap>
+        let psA: PubSubBaseProtocol
+        let psB: PubSubBaseProtocol
+        let psC: PubSubBaseProtocol
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -44,19 +45,31 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           registrarC = mockRegistrar()
 
           psA = await common.setup({
-            peerId: peerIdA,
-            registrar: registrarA,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdA,
+              registrar: registrarA
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psB = await common.setup({
-            peerId: peerIdB,
-            registrar: registrarB,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdB,
+              registrar: registrarB
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psC = await common.setup({
-            peerId: peerIdC,
-            registrar: registrarC,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdC,
+              registrar: registrarC
+            }),
+            init: {
+              emitSelf: true
+            }
           })
 
           // Start pubsub modes
@@ -172,7 +185,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
             waitForSubscriptionUpdate(psC, psB)
           ])
 
-          void psA.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
+          void psA.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail
@@ -233,7 +246,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
               waitForSubscriptionUpdate(psC, psB)
             ])
 
-            void psB.dispatchEvent(new CustomEvent(topic, { detail: uint8ArrayFromString('hey') }))
+            void psB.dispatchEvent(new CustomEvent<Uint8Array>(topic, { detail: uint8ArrayFromString('hey') }))
 
             function incMsg (evt: CustomEvent<Message>) {
               const msg = evt.detail
@@ -263,11 +276,11 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
         //   │b     d│
         // ◉─┘       └─◉
         // a
-        let psA: PubsubBaseProtocol<EventMap>
-        let psB: PubsubBaseProtocol<EventMap>
-        let psC: PubsubBaseProtocol<EventMap>
-        let psD: PubsubBaseProtocol<EventMap>
-        let psE: PubsubBaseProtocol<EventMap>
+        let psA: PubSubBaseProtocol
+        let psB: PubSubBaseProtocol
+        let psC: PubSubBaseProtocol
+        let psD: PubSubBaseProtocol
+        let psE: PubSubBaseProtocol
         let peerIdA: PeerId
         let peerIdB: PeerId
         let peerIdC: PeerId
@@ -294,29 +307,49 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
           registrarE = mockRegistrar()
 
           psA = await common.setup({
-            peerId: peerIdA,
-            registrar: registrarA,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdA,
+              registrar: registrarA
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psB = await common.setup({
-            peerId: peerIdB,
-            registrar: registrarB,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdB,
+              registrar: registrarB
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psC = await common.setup({
-            peerId: peerIdC,
-            registrar: registrarC,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdC,
+              registrar: registrarC
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psD = await common.setup({
-            peerId: peerIdD,
-            registrar: registrarD,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdD,
+              registrar: registrarD
+            }),
+            init: {
+              emitSelf: true
+            }
           })
           psE = await common.setup({
-            peerId: peerIdE,
-            registrar: registrarE,
-            emitSelf: true
+            components: new Components({
+              peerId: peerIdE,
+              registrar: registrarE
+            }),
+            init: {
+              emitSelf: true
+            }
           })
 
           // Start pubsub nodes
@@ -409,7 +442,7 @@ export default (common: TestSetup<PubsubBaseProtocol<EventMap>, PubSubOptions>)
             waitForSubscriptionUpdate(psE, psD)
           ])
 
-          void psC.dispatchEvent(new CustomEvent('Z', { detail: uint8ArrayFromString('hey from c') }))
+          void psC.dispatchEvent(new CustomEvent<Uint8Array>('Z', { detail: uint8ArrayFromString('hey from c') }))
 
           function incMsg (evt: CustomEvent<Message>) {
             const msg = evt.detail