@libp2p/pubsub 1.2.3 → 1.2.7

package/src/index.ts

@@ -1,13 +1,12 @@
 import { logger } from '@libp2p/logger'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces'
+import { EventEmitter, CustomEvent, EventHandler } from '@libp2p/interfaces'
 import errcode from 'err-code'
 import { pipe } from 'it-pipe'
 import Queue from 'p-queue'
 import { Topology } from '@libp2p/topology'
 import { codes } from './errors.js'
-import { RPC, IRPC } from './message/rpc.js'
-import { PeerStreams } from './peer-streams.js'
-import * as utils from './utils.js'
+import { PeerStreams as PeerStreamsImpl } from './peer-streams.js'
+import { toMessage, ensureArray, randomSeqno, noSignMsgId, msgId, toRpcMessage } from './utils.js'
 import {
   signMessage,
   verifySignature
@@ -15,9 +14,14 @@ import {
 import type { PeerId } from '@libp2p/interfaces/peer-id'
 import type { Registrar, IncomingStreamData } from '@libp2p/interfaces/registrar'
 import type { Connection } from '@libp2p/interfaces/connection'
-import type BufferList from 'bl'
-import type { PubSub, Message, StrictNoSign, StrictSign, PubsubOptions, PubsubEvents } from '@libp2p/interfaces/pubsub'
+import type { PubSub, Message, StrictNoSign, StrictSign, PubSubOptions, PubSubEvents, RPC, PeerStreams, RPCSubscription, RPCMessage } from '@libp2p/interfaces/pubsub'
 import type { Logger } from '@libp2p/logger'
+import { base58btc } from 'multiformats/bases/base58'
+import { peerMap } from '@libp2p/peer-map'
+import type { PeerMap } from '@libp2p/peer-map'
+import { peerIdFromString } from '@libp2p/peer-id'
+import type { IRPC } from './message/rpc.js'
+import { RPC as RPCProto } from './message/rpc.js'
 
 export interface TopicValidator { (topic: string, message: Message): Promise<void> }
 
@@ -25,7 +29,7 @@ export interface TopicValidator { (topic: string, message: Message): Promise<voi
  * PubsubBaseProtocol handles the peers and connections logic for pubsub routers
  * and specifies the API that pubsub routers should have.
  */
-export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap & PubsubEvents> implements PubSub<EventMap & PubsubEvents> {
+export abstract class PubsubBaseProtocol<EventMap extends PubSubEvents = PubSubEvents> extends EventEmitter<EventMap & PubSubEvents> implements PubSub<EventMap & PubSubEvents> {
   public peerId: PeerId
   public started: boolean
   /**
@@ -39,11 +43,11 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   /**
    * Map of peer streams
    */
-  public peers: Map<string, PeerStreams>
+  public peers: PeerMap<PeerStreams>
   /**
    * The signature policy to follow by default
    */
-  public globalSignaturePolicy: StrictNoSign | StrictSign
+  public globalSignaturePolicy: typeof StrictNoSign | typeof StrictSign
   /**
    * If router can relay received messages, even if not subscribed
    */
@@ -61,20 +65,21 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   public topicValidators: Map<string, TopicValidator>
   public queue: Queue
   public registrar: Registrar
+  public multicodecs: string[]
 
   protected log: Logger
-  protected multicodecs: string[]
   protected _libp2p: any
   private _registrarHandlerId: string | undefined
   private _registrarTopologyId: string | undefined
 
-  constructor (props: PubsubOptions) {
+  constructor (props: PubSubOptions) {
     super()
 
     const {
       debugName = 'libp2p:pubsub',
       multicodecs = [],
-      libp2p = null,
+      peerId,
+      registrar,
       globalSignaturePolicy = 'StrictSign',
       canRelayMessage = false,
       emitSelf = false,
@@ -82,14 +87,13 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     } = props
 
     this.log = logger(debugName)
-    this.multicodecs = utils.ensureArray(multicodecs)
-    this._libp2p = libp2p
-    this.registrar = libp2p.registrar
-    this.peerId = libp2p.peerId
+    this.multicodecs = ensureArray(multicodecs)
+    this.registrar = registrar
+    this.peerId = peerId
     this.started = false
     this.topics = new Map()
     this.subscriptions = new Set()
-    this.peers = new Map()
+    this.peers = peerMap<PeerStreams>()
     this.globalSignaturePolicy = globalSignaturePolicy === 'StrictNoSign' ? 'StrictNoSign' : 'StrictSign'
     this.canRelayMessage = canRelayMessage
     this.emitSelf = emitSelf
@@ -148,9 +152,11 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     }
 
     this.log('stopping')
-    this.peers.forEach((peerStreams) => peerStreams.close())
+    for (const peerStreams of this.peers.values()) {
+      peerStreams.close()
+    }
 
-    this.peers = new Map()
+    this.peers.clear()
     this.subscriptions = new Set()
     this.started = false
     this.log('stopped')
@@ -166,11 +172,10 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   protected _onIncomingStream (evt: CustomEvent<IncomingStreamData>) {
     const { protocol, stream, connection } = evt.detail
     const peerId = connection.remotePeer
-    const idB58Str = peerId.toString()
-    const peer = this._addPeer(peerId, protocol)
+    const peer = this.addPeer(peerId, protocol)
     const inboundStream = peer.attachInboundStream(stream)
 
-    this._processMessages(idB58Str, inboundStream, peer)
+    this.processMessages(peerId, inboundStream, peer)
       .catch(err => this.log(err))
   }
 
@@ -178,19 +183,18 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
    * Registrar notifies an established connection with pubsub protocol
    */
   protected async _onPeerConnected (peerId: PeerId, conn: Connection) {
-    const idB58Str = peerId.toString()
-    this.log('connected', idB58Str)
+    this.log('connected %p', peerId)
 
     try {
       const { stream, protocol } = await conn.newStream(this.multicodecs)
-      const peer = this._addPeer(peerId, protocol)
+      const peer = this.addPeer(peerId, protocol)
       await peer.attachOutboundStream(stream)
     } catch (err: any) {
       this.log.error(err)
     }
 
     // Immediately send my own subscriptions to the newly established conn
-    this._sendSubscriptions(idB58Str, Array.from(this.subscriptions), true)
+    this.send(peerId, { subscriptions: Array.from(this.subscriptions).map(sub => sub.toString()), subscribe: true })
   }
 
   /**
@@ -206,9 +210,8 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   /**
    * Notifies the router that a peer has been connected
    */
-  protected _addPeer (peerId: PeerId, protocol: string) {
-    const id = peerId.toString()
-    const existing = this.peers.get(id)
+  addPeer (peerId: PeerId, protocol: string): PeerStreams {
+    const existing = this.peers.get(peerId)
 
     // If peer streams already exists, do nothing
     if (existing != null) {
@@ -216,14 +219,14 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     }
 
     // else create a new peer streams
-    this.log('new peer', id)
+    this.log('new peer %p', peerId)
 
-    const peerStreams = new PeerStreams({
+    const peerStreams: PeerStreams = new PeerStreamsImpl({
       id: peerId,
       protocol
     })
 
-    this.peers.set(id, peerStreams)
+    this.peers.set(peerId, peerStreams)
     peerStreams.addEventListener('close', () => this._removePeer(peerId), {
       once: true
     })
@@ -236,7 +239,7 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
    */
   protected _removePeer (peerId: PeerId) {
     const id = peerId.toString()
-    const peerStreams = this.peers.get(id)
+    const peerStreams = this.peers.get(peerId)
     if (peerStreams == null) {
       return
     }
@@ -245,8 +248,8 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     peerStreams.close()
 
     // delete peer streams
-    this.log('delete peer', id)
-    this.peers.delete(id)
+    this.log('delete peer %p', peerId)
+    this.peers.delete(peerId)
 
     // remove peer from topics map
     for (const peers of this.topics.values()) {
@@ -261,20 +264,42 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   /**
    * Responsible for processing each RPC message received by other peers.
    */
-  async _processMessages (idB58Str: string, stream: AsyncIterable<Uint8Array|BufferList>, peerStreams: PeerStreams) {
+  async processMessages (peerId: PeerId, stream: AsyncIterable<Uint8Array>, peerStreams: PeerStreams) {
     try {
       await pipe(
         stream,
         async (source) => {
           for await (const data of source) {
-            const rpcBytes = data instanceof Uint8Array ? data : data.slice()
-            const rpcMsg = this._decodeRpc(rpcBytes)
-
-            // Since _processRpc may be overridden entirely in unsafe ways,
+            const rpcMsg = this.decodeRpc(data)
+            const messages: RPCMessage[] = []
+
+            for (const msg of (rpcMsg.messages ?? [])) {
+              if (msg.from == null || msg.data == null || msg.topic == null) {
+                this.log('message from %p was missing from, data or topic fields, dropping', peerId)
+                continue
+              }
+
+              messages.push({
+                from: msg.from,
+                data: msg.data,
+                topic: msg.topic,
+                seqno: msg.seqno ?? undefined,
+                signature: msg.signature ?? undefined,
+                key: msg.key ?? undefined
+              })
+            }
+
+            // Since processRpc may be overridden entirely in unsafe ways,
             // the simplest/safest option here is to wrap in a function and capture all errors
             // to prevent a top-level unhandled exception
             // This processing of rpc messages should happen without awaiting full validation/execution of prior messages
-            this._processRpc(idB58Str, peerStreams, rpcMsg)
+            this.processRpc(peerId, peerStreams, {
+              subscriptions: (rpcMsg.subscriptions).map(sub => ({
+                subscribe: Boolean(sub.subscribe),
+                topic: sub.topic ?? ''
+              })),
+              messages
+            })
               .catch(err => this.log(err))
           }
         }
@@ -287,54 +312,55 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
   /**
    * Handles an rpc request from a peer
    */
-  async _processRpc (idB58Str: string, peerStreams: PeerStreams, rpc: RPC) {
-    this.log('rpc from', idB58Str)
-    const subs = rpc.subscriptions
-    const msgs = rpc.msgs
+  async processRpc (from: PeerId, peerStreams: PeerStreams, rpc: RPC) {
+    if (!this.acceptFrom(from)) {
+      this.log('received message from unacceptable peer %p', from)
+      return
+    }
+
+    this.log('rpc from %p', from)
+
+    const { subscriptions, messages } = rpc
+
+    if (subscriptions.length > 0) {
+      this.log('subscription update from %p', from)
 
-    if (subs.length > 0) {
       // update peer subscriptions
-      subs.forEach((subOpt) => {
-        this._processRpcSubOpt(idB58Str, subOpt)
+      subscriptions.forEach((subOpt) => {
+        this.processRpcSubOpt(from, subOpt)
       })
-      this.dispatchEvent(new CustomEvent('pubsub:subscription-change', {
-        detail: { peerId: peerStreams.id, subscriptions: subs }
-      }))
-    }
 
-    if (!this._acceptFrom(idB58Str)) {
-      this.log('received message from unacceptable peer %s', idB58Str)
-      return false
+      super.dispatchEvent(new CustomEvent('pubsub:subscription-change', {
+        detail: { peerId: peerStreams.id, subscriptions }
+      }))
     }
 
-    if (msgs.length > 0) {
-      this.queue.addAll(msgs.map(message => async () => {
-        const topics = message.topicIDs != null ? message.topicIDs : []
-        const hasSubscription = topics.some((topic) => this.subscriptions.has(topic))
+    if (messages.length > 0) {
+      this.log('messages from %p', from)
 
-        if (!hasSubscription && !this.canRelayMessage) {
+      this.queue.addAll(messages.map(message => async () => {
+        if (!this.subscriptions.has(message.topic) && !this.canRelayMessage) {
           this.log('received message we didn\'t subscribe to. Dropping.')
           return
         }
 
         try {
-          const msg = utils.normalizeInRpcMessage(message, idB58Str)
+          const msg = await toMessage(message)
 
-          await this._processRpcMessage(msg)
+          await this.processMessage(from, msg)
         } catch (err: any) {
           this.log.error(err)
         }
       }))
         .catch(err => this.log(err))
     }
-    return true
   }
 
   /**
    * Handles a subscription change from a peer
    */
-  _processRpcSubOpt (id: string, subOpt: RPC.ISubOpts) {
-    const t = subOpt.topicID
+  processRpcSubOpt (id: PeerId, subOpt: RPCSubscription) {
+    const t = subOpt.topic
 
     if (t == null) {
       return
@@ -346,20 +372,20 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
       this.topics.set(t, topicSet)
     }
 
-    if (subOpt.subscribe === true) {
+    if (subOpt.subscribe) {
       // subscribe peer to new topic
-      topicSet.add(id)
+      topicSet.add(id.toString())
     } else {
       // unsubscribe from existing topic
-      topicSet.delete(id)
+      topicSet.delete(id.toString())
     }
   }
 
   /**
    * Handles an message from a peer
    */
-  async _processRpcMessage (msg: Message) {
-    if ((msg.from != null) && this.peerId.equals(msg.from) && !this.emitSelf) {
+  async processMessage (from: PeerId, msg: Message) {
+    if (this.peerId.equals(from) && !this.emitSelf) {
       return
     }
 
@@ -371,23 +397,17 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
       return
     }
 
-    // Emit to self
-    this._emitMessage(msg)
-
-    return await this._publish(utils.normalizeOutRpcMessage(msg))
-  }
+    if (this.subscriptions.has(msg.topic)) {
+      const isFromSelf = this.peerId.equals(from)
 
-  /**
-   * Emit a message from a peer
-   */
-  _emitMessage (message: Message) {
-    message.topicIDs.forEach((topic) => {
-      if (this.subscriptions.has(topic)) {
-        this.dispatchEvent(new CustomEvent(topic, {
-          detail: message
+      if (!isFromSelf || this.emitSelf) {
+        super.dispatchEvent(new CustomEvent(msg.topic, {
+          detail: msg
         }))
       }
-    })
+    }
+
+    await this.publishMessage(from, msg)
   }
 
   /**
@@ -398,10 +418,17 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     const signaturePolicy = this.globalSignaturePolicy
     switch (signaturePolicy) {
       case 'StrictSign':
-        // @ts-expect-error seqno is optional in protobuf definition but it will exist
-        return utils.msgId(msg.from, msg.seqno)
+        if (msg.seqno == null) {
+          throw errcode(new Error('Need seqno when signature policy is StrictSign but it was missing'), codes.ERR_MISSING_SEQNO)
+        }
+
+        if (msg.key == null) {
+          throw errcode(new Error('Need key when signature policy is StrictSign but it was missing'), codes.ERR_MISSING_KEY)
+        }
+
+        return msgId(msg.key, msg.seqno)
       case 'StrictNoSign':
-        return utils.noSignMsgId(msg.data)
+        return noSignMsgId(msg.data)
       default:
         throw errcode(new Error('Cannot get message id: unhandled signature policy'), codes.ERR_UNHANDLED_SIGNATURE_POLICY)
     }
@@ -411,7 +438,7 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
    * Whether to accept a message from a peer
    * Override to create a graylist
    */
-  _acceptFrom (id: string) {
+  acceptFrom (id: PeerId) {
     return true
   }
 
@@ -419,39 +446,44 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
    * Decode Uint8Array into an RPC object.
    * This can be override to use a custom router protobuf.
    */
-  _decodeRpc (bytes: Uint8Array) {
-    return RPC.decode(bytes)
+  decodeRpc (bytes: Uint8Array) {
+    return RPCProto.decode(bytes)
   }
 
   /**
    * Encode RPC object into a Uint8Array.
    * This can be override to use a custom router protobuf.
    */
-  _encodeRpc (rpc: IRPC) {
-    return RPC.encode(rpc).finish()
+  encodeRpc (rpc: IRPC) {
+    return RPCProto.encode(rpc).finish()
   }
 
   /**
    * Send an rpc object to a peer
    */
-  _sendRpc (id: string, rpc: IRPC) {
-    const peerStreams = this.peers.get(id)
-    if ((peerStreams == null) || !peerStreams.isWritable) {
-      const msg = `Cannot send RPC to ${id} as there is no open stream to it available`
+  send (peer: PeerId, data: { messages?: Message[], subscriptions?: string[], subscribe?: boolean }) {
+    const { messages, subscriptions, subscribe } = data
 
-      this.log.error(msg)
-      return
-    }
-    peerStreams.write(this._encodeRpc(rpc))
+    return this.sendRpc(peer, {
+      subscriptions: (subscriptions ?? []).map(str => ({ topic: str, subscribe: Boolean(subscribe) })),
+      messages: (messages ?? []).map(toRpcMessage)
+    })
   }
 
   /**
-   * Send subscriptions to a peer
+   * Send an rpc object to a peer
    */
-  _sendSubscriptions (id: string, topics: string[], subscribe: boolean) {
-    return this._sendRpc(id, {
-      subscriptions: topics.map(t => ({ topicID: t, subscribe: subscribe }))
-    })
+  sendRpc (peer: PeerId, rpc: IRPC) {
+    const peerStreams = this.peers.get(peer)
+
+    if (peerStreams == null || !peerStreams.isWritable) {
+      const msg = `Cannot send RPC to ${peer.toString(base58btc)} as there is no open stream to it available`
+
+      this.log.error(msg)
+      return
+    }
+
+    peerStreams.write(this.encodeRpc(rpc))
   }
 
   /**
@@ -462,9 +494,6 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
     const signaturePolicy = this.globalSignaturePolicy
     switch (signaturePolicy) {
       case 'StrictNoSign':
-        if (message.from != null) {
-          throw errcode(new Error('StrictNoSigning: from should not be present'), codes.ERR_UNEXPECTED_FROM)
-        }
         if (message.signature != null) {
           throw errcode(new Error('StrictNoSigning: signature should not be present'), codes.ERR_UNEXPECTED_SIGNATURE)
         }
@@ -490,11 +519,10 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
         throw errcode(new Error('Cannot validate message: unhandled signature policy'), codes.ERR_UNHANDLED_SIGNATURE_POLICY)
     }
 
-    for (const topic of message.topicIDs) {
-      const validatorFn = this.topicValidators.get(topic)
-      if (validatorFn != null) {
-        await validatorFn(topic, message)
-      }
+    const validatorFn = this.topicValidators.get(message.topic)
+
+    if (validatorFn != null) {
+      await validatorFn(message.topic, message)
     }
   }
 
@@ -502,12 +530,11 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
    * Normalizes the message and signs it, if signing is enabled.
    * Should be used by the routers to create the message to send.
    */
-  protected async _buildMessage (message: Message) {
+  async buildMessage (message: Message) {
     const signaturePolicy = this.globalSignaturePolicy
     switch (signaturePolicy) {
       case 'StrictSign':
-        message.from = this.peerId.multihash.bytes
-        message.seqno = utils.randomSeqno()
+        message.seqno = randomSeqno()
         return await signMessage(this.peerId, message)
       case 'StrictNoSign':
         return await Promise.resolve(message)
@@ -530,48 +557,67 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
       throw errcode(new Error('topic is required'), 'ERR_NOT_VALID_TOPIC')
     }
 
-    const peersInTopic = this.topics.get(topic)
+    const peersInTopic = this.topics.get(topic.toString())
 
     if (peersInTopic == null) {
       return []
     }
 
-    return Array.from(peersInTopic)
+    return Array.from(peersInTopic).map(str => peerIdFromString(str))
   }
 
   /**
    * Publishes messages to all subscribed peers
    */
-  async publish (topic: string, message: Uint8Array) {
+  dispatchEvent (event: CustomEvent): boolean {
     if (!this.started) {
       throw new Error('Pubsub has not started')
     }
 
-    this.log('publish', topic, message)
+    const topic = event.type
+    let message: Message = event.detail
 
-    const from = this.peerId.toString()
-    const msgObject = {
-      receivedFrom: from,
-      data: message,
-      topicIDs: [topic]
+    if (message instanceof Uint8Array) {
+      message = {
+        from: this.peerId,
+        topic,
+        data: message
+      }
     }
 
-    // ensure that the message follows the signature policy
-    const outMsg = await this._buildMessage(msgObject)
-    const msg = utils.normalizeInRpcMessage(outMsg)
+    this.log('publish', topic, message)
+
+    Promise.resolve().then(async () => {
+      message = await this.buildMessage(message)
+
+      // dispatch the event if we are interested
+      if (this.emitSelf) {
+        if (this.subscriptions.has(topic)) {
+          super.dispatchEvent(new CustomEvent(topic, {
+            detail: message
+          }))
+
+          if (this.listenerCount(topic) === 0) {
+            this.unsubscribe(topic)
+          }
+        }
+      }
 
-    // Emit to self if I'm interested and emitSelf enabled
-    this.emitSelf && this._emitMessage(msg)
+      // send to all the other peers
+      await this.publishMessage(this.peerId, message)
+    })
+      .catch(err => {
+        this.log.error(err)
+      })
 
-    // send to all the other peers
-    await this._publish(msg)
+    return true
   }
 
   /**
    * Overriding the implementation of publish should handle the appropriate algorithms for the publish/subscriber implementation.
    * For example, a Floodsub implementation might simply publish each message to each topic for every peer
    */
-  abstract _publish (message: Message): Promise<void>
+  abstract publishMessage (peerId: PeerId, message: Message): Promise<void>
 
   /**
    * Subscribes to a given topic.
@@ -581,23 +627,49 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
       throw new Error('Pubsub has not started')
     }
 
-    if (!this.subscriptions.has(topic)) {
-      this.subscriptions.add(topic)
-      this.peers.forEach((_, id) => this._sendSubscriptions(id, [topic], true))
+    const topicStr = topic.toString()
+
+    if (topicStr === 'pubsub:subscription-change') {
+      return
+    }
+
+    if (!this.subscriptions.has(topicStr)) {
+      this.subscriptions.add(topicStr)
+
+      for (const peerId of this.peers.keys()) {
+        this.send(peerId, { subscriptions: [topicStr], subscribe: true })
+      }
     }
   }
 
   /**
-   * Unsubscribe from the given topic.
+   * Unsubscribe from the given topic
    */
   unsubscribe (topic: string) {
     if (!this.started) {
       throw new Error('Pubsub is not started')
     }
 
-    if (this.subscriptions.has(topic) && this.listenerCount(topic) === 0) {
-      this.subscriptions.delete(topic)
-      this.peers.forEach((_, id) => this._sendSubscriptions(id, [topic], false))
+    // @ts-expect-error topic should be a key of the event map
+    super.removeEventListener(topic)
+
+    const topicStr = topic.toString()
+
+    if (topicStr === 'pubsub:subscription-change') {
+      return
+    }
+
+    const wasSubscribed = this.subscriptions.has(topicStr)
+    const listeners = this.listenerCount(topicStr)
+
+    this.log('unsubscribe from %s - am subscribed %s, listeners %d', topic, wasSubscribed, listeners)
+
+    if (wasSubscribed && listeners === 0) {
+      this.subscriptions.delete(topicStr)
+
+      for (const peerId of this.peers.keys()) {
+        this.send(peerId, { subscriptions: [topicStr], subscribe: false })
+      }
     }
   }
 
@@ -611,4 +683,28 @@ export abstract class PubsubBaseProtocol<EventMap> extends EventEmitter<EventMap
 
     return Array.from(this.subscriptions)
   }
+
+  getPeers () {
+    if (!this.started) {
+      throw new Error('Pubsub is not started')
+    }
+
+    return Array.from(this.peers.keys())
+  }
+
+  addEventListener<U extends keyof EventMap> (type: U, callback: EventHandler<EventMap[U]>, options?: AddEventListenerOptions | boolean) {
+    this.subscribe(type.toString())
+
+    super.addEventListener(type, callback, options)
+  }
+
+  removeEventListener<U extends keyof EventMap> (type: U, callback: EventHandler<EventMap[U]> | undefined, options?: EventListenerOptions | boolean) {
+    super.removeEventListener(type, callback, options)
+
+    const topicStr = type.toString()
+
+    if (this.listenerCount(topicStr) === 0) {
+      this.unsubscribe(topicStr)
+    }
+  }
 }