@libp2p/pubsub 8.0.10 → 8.0.11-551622a96

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@libp2p/pubsub",
-  "version": "8.0.10",
+  "version": "8.0.11-551622a96",
   "description": "libp2p pubsub base class",
   "license": "Apache-2.0 OR MIT",
-  "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/pubsub#readme",
+  "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/pubsub#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/libp2p/js-libp2p.git"
@@ -11,6 +11,10 @@
   "bugs": {
     "url": "https://github.com/libp2p/js-libp2p/issues"
   },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "keywords": [
     "interface",
     "libp2p"
@@ -67,7 +71,7 @@
   "scripts": {
     "clean": "aegir clean",
     "lint": "aegir lint",
-    "dep-check": "aegir dep-check -i protons",
+    "dep-check": "aegir dep-check",
     "build": "aegir build",
     "generate": "protons test/message/rpc.proto",
     "test": "aegir test",
@@ -79,30 +83,30 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/crypto": "^2.0.8",
-    "@libp2p/interface": "^0.1.6",
-    "@libp2p/interface-internal": "^0.1.9",
-    "@libp2p/logger": "^3.1.0",
-    "@libp2p/peer-collections": "^4.0.8",
-    "@libp2p/peer-id": "^3.0.6",
-    "abortable-iterator": "^5.0.1",
-    "it-length-prefixed": "^9.0.1",
+    "@libp2p/crypto": "3.0.0-551622a96",
+    "@libp2p/interface": "1.0.0-551622a96",
+    "@libp2p/interface-internal": "0.1.10-551622a96",
+    "@libp2p/peer-collections": "4.0.9-551622a96",
+    "@libp2p/peer-id": "4.0.0-551622a96",
+    "@libp2p/utils": "5.0.0-551622a96",
+    "it-length-prefixed": "^9.0.3",
     "it-pipe": "^3.0.1",
-    "it-pushable": "^3.2.0",
-    "multiformats": "^12.0.1",
-    "p-queue": "^7.3.4",
+    "it-pushable": "^3.2.1",
+    "multiformats": "^12.1.3",
+    "p-queue": "^7.4.1",
     "uint8arraylist": "^2.4.3",
     "uint8arrays": "^4.0.6"
   },
   "devDependencies": {
-    "@libp2p/peer-id-factory": "^3.0.8",
+    "@libp2p/logger": "4.0.0-551622a96",
+    "@libp2p/peer-id-factory": "3.0.9-551622a96",
     "@types/sinon": "^17.0.0",
     "aegir": "^41.0.2",
     "delay": "^6.0.0",
     "it-pair": "^2.0.6",
     "p-defer": "^4.0.0",
     "p-wait-for": "^5.0.2",
-    "protons": "^7.0.2",
+    "protons": "^7.3.0",
     "protons-runtime": "^5.0.0",
     "sinon": "^17.0.0"
   }

package/src/index.ts

@@ -13,10 +13,8 @@
  * ```
  */
 
-import { CodeError } from '@libp2p/interface/errors'
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
-import { type PubSub, type Message, type StrictNoSign, type StrictSign, type PubSubInit, type PubSubEvents, type PeerStreams, type PubSubRPCMessage, type PubSubRPC, type PubSubRPCSubscription, type SubscriptionChangeData, type PublishResult, type TopicValidatorFn, TopicValidatorResult } from '@libp2p/interface/pubsub'
-import { logger } from '@libp2p/logger'
+import { CodeError, TypedEventEmitter, CustomEvent } from '@libp2p/interface'
+import { type PubSub, type Message, type StrictNoSign, type StrictSign, type PubSubInit, type PubSubEvents, type PeerStreams, type PubSubRPCMessage, type PubSubRPC, type PubSubRPCSubscription, type SubscriptionChangeData, type PublishResult, type TopicValidatorFn, TopicValidatorResult, type ComponentLogger, type Logger, type Connection, type PeerId } from '@libp2p/interface'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { pipe } from 'it-pipe'
 import Queue from 'p-queue'
@@ -27,16 +25,13 @@ import {
   verifySignature
 } from './sign.js'
 import { toMessage, ensureArray, noSignMsgId, msgId, toRpcMessage, randomSeqno } from './utils.js'
-import type { Connection } from '@libp2p/interface/connection'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
-const log = logger('libp2p:pubsub')
-
 export interface PubSubComponents {
   peerId: PeerId
   registrar: Registrar
+  logger: ComponentLogger
 }
 
 /**
@@ -44,6 +39,8 @@ export interface PubSubComponents {
  * and specifies the API that pubsub routers should have.
  */
 export abstract class PubSubBaseProtocol<Events extends Record<string, any> = PubSubEvents> extends TypedEventEmitter<Events> implements PubSub<Events> {
+  protected log: Logger
+
   public started: boolean
   /**
    * Map of topics to which peers are subscribed to
@@ -98,6 +95,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
       maxOutboundStreams = 1
     } = props
 
+    this.log = components.logger.forComponent('libp2p:pubsub')
     this.components = components
     this.multicodecs = ensureArray(multicodecs)
     this.enabled = props.enabled !== false
@@ -128,7 +126,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
       return
     }
 
-    log('starting')
+    this.log('starting')
 
     const registrar = this.components.registrar
     // Incoming streams
@@ -148,7 +146,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     }
     this._registrarTopologyIds = await Promise.all(this.multicodecs.map(async multicodec => registrar.register(multicodec, topology)))
 
-    log('started')
+    this.log('started')
     this.started = true
   }
 
@@ -173,7 +171,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
       await registrar.unhandle(multicodec)
     }))
 
-    log('stopping')
+    this.log('stopping')
     for (const peerStreams of this.peers.values()) {
       peerStreams.close()
     }
@@ -181,7 +179,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     this.peers.clear()
     this.subscriptions = new Set()
     this.started = false
-    log('stopped')
+    this.log('stopped')
   }
 
   isStarted (): boolean {
@@ -204,18 +202,18 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     const inboundStream = peer.attachInboundStream(stream)
 
     this.processMessages(peerId, inboundStream, peer)
-      .catch(err => { log(err) })
+      .catch(err => { this.log(err) })
   }
 
   /**
    * Registrar notifies an established connection with pubsub protocol
    */
   protected _onPeerConnected (peerId: PeerId, conn: Connection): void {
-    log('connected %p', peerId)
+    this.log('connected %p', peerId)
 
     // if this connection is already in use for pubsub, ignore it
     if (conn.streams.find(stream => stream.direction === 'outbound' && stream.protocol != null && this.multicodecs.includes(stream.protocol)) != null) {
-      log('outbound pubsub streams already present on connection from %p', peerId)
+      this.log('outbound pubsub streams already present on connection from %p', peerId)
       return
     }
 
@@ -231,14 +229,14 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
         const peer = this.addPeer(peerId, stream.protocol)
         await peer.attachOutboundStream(stream)
       } catch (err: any) {
-        log.error(err)
+        this.log.error(err)
       }
 
       // Immediately send my own subscriptions to the newly established conn
       this.send(peerId, { subscriptions: Array.from(this.subscriptions).map(sub => sub.toString()), subscribe: true })
     })
       .catch(err => {
-        log.error(err)
+        this.log.error(err)
       })
   }
 
@@ -248,7 +246,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
   protected _onPeerDisconnected (peerId: PeerId, conn?: Connection): void {
     const idB58Str = peerId.toString()
 
-    log('connection ended', idB58Str)
+    this.log('connection ended', idB58Str)
     this._removePeer(peerId)
   }
 
@@ -264,9 +262,9 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     }
 
     // else create a new peer streams
-    log('new peer %p', peerId)
+    this.log('new peer %p', peerId)
 
-    const peerStreams: PeerStreams = new PeerStreamsImpl({
+    const peerStreams: PeerStreams = new PeerStreamsImpl(this.components, {
       id: peerId,
       protocol
     })
@@ -292,7 +290,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     peerStreams.close()
 
     // delete peer streams
-    log('delete peer %p', peerId)
+    this.log('delete peer %p', peerId)
     this.peers.delete(peerId)
 
     // remove peer from topics map
@@ -319,7 +317,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
 
             for (const msg of (rpcMsg.messages ?? [])) {
               if (msg.from == null || msg.data == null || msg.topic == null) {
-                log('message from %p was missing from, data or topic fields, dropping', peerId)
+                this.log('message from %p was missing from, data or topic fields, dropping', peerId)
                 continue
               }
 
@@ -344,7 +342,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
               })),
               messages
             })
-              .catch(err => { log(err) })
+              .catch(err => { this.log(err) })
           }
         }
       )
@@ -358,16 +356,16 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
    */
   async processRpc (from: PeerId, peerStreams: PeerStreams, rpc: PubSubRPC): Promise<boolean> {
     if (!this.acceptFrom(from)) {
-      log('received message from unacceptable peer %p', from)
+      this.log('received message from unacceptable peer %p', from)
       return false
     }
 
-    log('rpc from %p', from)
+    this.log('rpc from %p', from)
 
     const { subscriptions, messages } = rpc
 
     if (subscriptions != null && subscriptions.length > 0) {
-      log('subscription update from %p', from)
+      this.log('subscription update from %p', from)
 
       // update peer subscriptions
       subscriptions.forEach((subOpt) => {
@@ -386,11 +384,11 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     }
 
     if (messages != null && messages.length > 0) {
-      log('messages from %p', from)
+      this.log('messages from %p', from)
 
       this.queue.addAll(messages.map(message => async () => {
         if (message.topic == null || (!this.subscriptions.has(message.topic) && !this.canRelayMessage)) {
-          log('received message we didn\'t subscribe to. Dropping.')
+          this.log('received message we didn\'t subscribe to. Dropping.')
           return false
         }
 
@@ -399,10 +397,10 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
 
           await this.processMessage(from, msg)
         } catch (err: any) {
-          log.error(err)
+          this.log.error(err)
         }
       }))
-        .catch(err => { log(err) })
+        .catch(err => { this.log(err) })
     }
 
     return true
@@ -445,7 +443,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     try {
       await this.validate(from, msg)
     } catch (err: any) {
-      log('Message is invalid, dropping it. %O', err)
+      this.log('Message is invalid, dropping it. %O', err)
       return
     }
 
@@ -535,13 +533,13 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
     const peerStreams = this.peers.get(peer)
 
     if (peerStreams == null) {
-      log.error('Cannot send RPC to %p as there are no streams to it available', peer)
+      this.log.error('Cannot send RPC to %p as there are no streams to it available', peer)
 
       return
     }
 
     if (!peerStreams.isWritable) {
-      log.error('Cannot send RPC to %p as there is no outbound stream to it available', peer)
+      this.log.error('Cannot send RPC to %p as there is no outbound stream to it available', peer)
 
       return
     }
@@ -664,7 +662,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
       sequenceNumber: randomSeqno()
     }
 
-    log('publish topic: %s from: %p data: %m', topic, message.from, message.data)
+    this.log('publish topic: %s from: %p data: %m', topic, message.from, message.data)
 
     const rpcMessage = await this.buildMessage(message)
     let emittedToSelf = false
@@ -706,7 +704,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
       throw new Error('Pubsub has not started')
     }
 
-    log('subscribe to topic: %s', topic)
+    this.log('subscribe to topic: %s', topic)
 
     if (!this.subscriptions.has(topic)) {
       this.subscriptions.add(topic)
@@ -729,7 +727,7 @@ export abstract class PubSubBaseProtocol<Events extends Record<string, any> = Pu
 
     const wasSubscribed = this.subscriptions.has(topic)
 
-    log('unsubscribe from %s - am subscribed %s', topic, wasSubscribed)
+    this.log('unsubscribe from %s - am subscribed %s', topic, wasSubscribed)
 
     if (wasSubscribed) {
       this.subscriptions.delete(topic)

package/src/peer-streams.ts

@@ -1,22 +1,21 @@
-import { TypedEventEmitter, CustomEvent } from '@libp2p/interface/events'
-import { logger } from '@libp2p/logger'
-import { abortableSource } from 'abortable-iterator'
+import { TypedEventEmitter, CustomEvent } from '@libp2p/interface'
+import { closeSource } from '@libp2p/utils/close-source'
 import * as lp from 'it-length-prefixed'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
 import { Uint8ArrayList } from 'uint8arraylist'
-import type { Stream } from '@libp2p/interface/connection'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerStreamEvents } from '@libp2p/interface/pubsub'
+import type { ComponentLogger, Logger, Stream, PeerId, PeerStreamEvents } from '@libp2p/interface'
 import type { Pushable } from 'it-pushable'
 
-const log = logger('libp2p-pubsub:peer-streams')
-
 export interface PeerStreamsInit {
   id: PeerId
   protocol: string
 }
 
+export interface PeerStreamsComponents {
+  logger: ComponentLogger
+}
+
 /**
  * Thin wrapper around a peer's inbound / outbound pubsub streams
  */
@@ -44,10 +43,12 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
    */
   private readonly _inboundAbortController: AbortController
   private closed: boolean
+  private readonly log: Logger
 
-  constructor (init: PeerStreamsInit) {
+  constructor (components: PeerStreamsComponents, init: PeerStreamsInit) {
     super()
 
+    this.log = components.logger.forComponent('libp2p-pubsub:peer-streams')
     this.id = init.id
     this.protocol = init.protocol
 
@@ -86,18 +87,22 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
    * Attach a raw inbound stream and setup a read stream
    */
   attachInboundStream (stream: Stream): AsyncIterable<Uint8ArrayList> {
+    const abortListener = (): void => {
+      closeSource(stream.source, this.log)
+    }
+
+    this._inboundAbortController.signal.addEventListener('abort', abortListener, {
+      once: true
+    })
+
     // Create and attach a new inbound stream
     // The inbound stream is:
     // - abortable, set to only return on abort, rather than throw
     // - transformed with length-prefix transform
     this._rawInboundStream = stream
-    this.inboundStream = abortableSource(
-      pipe(
-        this._rawInboundStream,
-        (source) => lp.decode(source)
-      ),
-      this._inboundAbortController.signal,
-      { returnOnAbort: true }
+    this.inboundStream = pipe(
+      this._rawInboundStream,
+      (source) => lp.decode(source)
     )
 
     this.dispatchEvent(new CustomEvent('stream:inbound'))
@@ -117,13 +122,12 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
 
     this._rawOutboundStream = stream
     this.outboundStream = pushable<Uint8ArrayList>({
-      objectMode: true,
       onEnd: (shouldEmit) => {
         // close writable side of the stream
         if (this._rawOutboundStream != null) { // eslint-disable-line @typescript-eslint/prefer-optional-chain
           this._rawOutboundStream.closeWrite()
             .catch(err => {
-              log('error closing outbound stream', err)
+              this.log('error closing outbound stream', err)
             })
         }
 
@@ -140,7 +144,7 @@ export class PeerStreams extends TypedEventEmitter<PeerStreamEvents> {
       (source) => lp.encode(source),
       this._rawOutboundStream
     ).catch((err: Error) => {
-      log.error(err)
+      this.log.error(err)
     })
 
     // Only emit if the connection is new

package/src/sign.ts

@@ -3,8 +3,7 @@ import { peerIdFromKeys } from '@libp2p/peer-id'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toRpcMessage } from './utils.js'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PubSubRPCMessage, SignedMessage } from '@libp2p/interface/pubsub'
+import type { PeerId, PubSubRPCMessage, SignedMessage } from '@libp2p/interface'
 
 export const SignPrefix = uint8ArrayFromString('libp2p-pubsub:')
 

package/src/utils.ts

@@ -1,11 +1,11 @@
 import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interface/errors'
+import { CodeError } from '@libp2p/interface'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { codes } from './errors.js'
-import type { Message, PubSubRPCMessage } from '@libp2p/interface/pubsub'
+import type { Message, PubSubRPCMessage } from '@libp2p/interface'
 
 /**
  * Generate a random sequence number

package/dist/typedoc-urls.json

@@ -1,30 +0,0 @@
-{
-  "codes": "https://libp2p.github.io/js-libp2p/variables/_libp2p_pubsub.errors.codes.html",
-  "./errors:codes": "https://libp2p.github.io/js-libp2p/variables/_libp2p_pubsub.errors.codes.html",
-  "PubSubBaseProtocol": "https://libp2p.github.io/js-libp2p/classes/_libp2p_pubsub.index.PubSubBaseProtocol.html",
-  ".:PubSubBaseProtocol": "https://libp2p.github.io/js-libp2p/classes/_libp2p_pubsub.index.PubSubBaseProtocol.html",
-  "PubSubComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_pubsub.index.PubSubComponents.html",
-  ".:PubSubComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_pubsub.index.PubSubComponents.html",
-  "PeerStreams": "https://libp2p.github.io/js-libp2p/classes/_libp2p_pubsub.peer_streams.PeerStreams.html",
-  "./peer-streams:PeerStreams": "https://libp2p.github.io/js-libp2p/classes/_libp2p_pubsub.peer_streams.PeerStreams.html",
-  "PeerStreamsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_pubsub.peer_streams.PeerStreamsInit.html",
-  "./peer-streams:PeerStreamsInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_pubsub.peer_streams.PeerStreamsInit.html",
-  "anyMatch": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.anyMatch.html",
-  "./utils:anyMatch": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.anyMatch.html",
-  "bigIntFromBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.bigIntFromBytes.html",
-  "./utils:bigIntFromBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.bigIntFromBytes.html",
-  "bigIntToBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.bigIntToBytes.html",
-  "./utils:bigIntToBytes": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.bigIntToBytes.html",
-  "ensureArray": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.ensureArray.html",
-  "./utils:ensureArray": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.ensureArray.html",
-  "msgId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.msgId.html",
-  "./utils:msgId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.msgId.html",
-  "noSignMsgId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.noSignMsgId.html",
-  "./utils:noSignMsgId": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.noSignMsgId.html",
-  "randomSeqno": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.randomSeqno.html",
-  "./utils:randomSeqno": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.randomSeqno.html",
-  "toMessage": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.toMessage.html",
-  "./utils:toMessage": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.toMessage.html",
-  "toRpcMessage": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.toRpcMessage.html",
-  "./utils:toRpcMessage": "https://libp2p.github.io/js-libp2p/functions/_libp2p_pubsub.utils.toRpcMessage.html"
-}