@libp2p/identify 3.0.38 → 3.0.39-6059227cb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/identify",
-  "version": "3.0.38",
+  "version": "3.0.39-6059227cb",
   "description": "Implementation of the Identify Protocol",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/protocol-identify#readme",
@@ -45,30 +45,27 @@
     "doc-check": "aegir doc-check"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.1.7",
-    "@libp2p/interface": "^2.10.5",
-    "@libp2p/interface-internal": "^2.3.18",
-    "@libp2p/peer-id": "^5.1.8",
-    "@libp2p/peer-record": "^8.0.34",
-    "@libp2p/utils": "^6.7.1",
-    "@multiformats/multiaddr": "^12.4.4",
-    "@multiformats/multiaddr-matcher": "^2.0.0",
-    "it-drain": "^3.0.9",
-    "it-parallel": "^3.0.11",
-    "it-protobuf-stream": "^2.0.2",
+    "@libp2p/crypto": "5.1.8-6059227cb",
+    "@libp2p/interface": "2.11.0-6059227cb",
+    "@libp2p/interface-internal": "2.3.19-6059227cb",
+    "@libp2p/peer-id": "5.1.9-6059227cb",
+    "@libp2p/peer-record": "8.0.35-6059227cb",
+    "@libp2p/utils": "6.7.2-6059227cb",
+    "@multiformats/multiaddr": "^13.0.1",
+    "@multiformats/multiaddr-matcher": "^3.0.1",
+    "it-drain": "^3.0.10",
+    "it-parallel": "^3.0.13",
     "main-event": "^1.0.1",
-    "protons-runtime": "^5.5.0",
+    "protons-runtime": "^5.6.0",
     "uint8arraylist": "^2.4.8",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "@libp2p/logger": "^5.1.21",
-    "aegir": "^47.0.14",
+    "@libp2p/logger": "5.2.0-6059227cb",
+    "aegir": "^47.0.22",
     "delay": "^6.0.0",
     "it-length-prefixed": "^10.0.1",
-    "it-pair": "^2.0.6",
-    "it-pushable": "^3.2.3",
-    "protons": "^7.6.1",
+    "protons": "^7.7.0",
     "sinon-ts": "^2.0.0"
   },
   "sideEffects": false

package/src/identify-push.ts

@@ -1,10 +1,9 @@
 import { serviceCapabilities } from '@libp2p/interface'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import { debounce } from '@libp2p/utils/debounce'
-import { protocols } from '@multiformats/multiaddr'
+import { debounce, pbStream } from '@libp2p/utils'
+import { CODE_P2P } from '@multiformats/multiaddr'
 import drain from 'it-drain'
 import parallel from 'it-parallel'
-import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
@@ -16,7 +15,7 @@ import {
 import { Identify as IdentifyMessage } from './pb/message.js'
 import { AbstractIdentify, consumeIdentifyMessage, defaultValues } from './utils.js'
 import type { IdentifyPush as IdentifyPushInterface, IdentifyPushComponents, IdentifyPushInit } from './index.js'
-import type { Stream, Startable, IncomingStreamData } from '@libp2p/interface'
+import type { Stream, Startable, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export class IdentifyPush extends AbstractIdentify implements Startable, IdentifyPushInterface {
@@ -64,21 +63,21 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
     }
 
     try {
-      const listenAddresses = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+      const listenAddresses = this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(CODE_P2P))
       const peerRecord = new PeerRecord({
-        peerId: this.peerId,
+        peerId: this.components.peerId,
         multiaddrs: listenAddresses
       })
-      const signedPeerRecord = await RecordEnvelope.seal(peerRecord, this.privateKey)
-      const supportedProtocols = this.registrar.getProtocols()
-      const peer = await this.peerStore.get(this.peerId)
+      const signedPeerRecord = await RecordEnvelope.seal(peerRecord, this.components.privateKey)
+      const supportedProtocols = this.components.registrar.getProtocols()
+      const peer = await this.components.peerStore.get(this.components.peerId)
       const agentVersion = uint8ArrayToString(peer.metadata.get('AgentVersion') ?? uint8ArrayFromString(this.host.agentVersion))
       const protocolVersion = uint8ArrayToString(peer.metadata.get('ProtocolVersion') ?? uint8ArrayFromString(this.host.protocolVersion))
       const self = this
 
       async function * pushToConnections (): AsyncGenerator<() => Promise<void>> {
         for (const connection of self.connectionManager.getConnections()) {
-          const peer = await self.peerStore.get(connection.remotePeer)
+          const peer = await self.components.peerStore.get(connection.remotePeer)
 
           if (!peer.protocols.includes(self.protocol)) {
             continue
@@ -114,8 +113,9 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
                 signal
               })
             } catch (err: any) {
-              // Just log errors
-              self.log.error('could not push identify update to peer', err)
+              // Just log errors if the stream was opened
+              const log = stream?.log.newScope('identify-push')
+              log?.error('could not push identify update to peer', err)
               stream?.abort(err)
             }
           }
@@ -133,32 +133,26 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
   /**
    * Reads the Identify Push message from the given `connection`
    */
-  async handleProtocol (data: IncomingStreamData): Promise<void> {
-    const { connection, stream } = data
+  async handleProtocol (stream: Stream, connection: Connection): Promise<void> {
+    const log = stream.log.newScope('identify-push')
 
-    try {
-      if (this.peerId.equals(connection.remotePeer)) {
-        throw new Error('received push from ourselves?')
-      }
+    if (this.components.peerId.equals(connection.remotePeer)) {
+      throw new Error('received push from ourselves?')
+    }
 
-      const options = {
-        signal: AbortSignal.timeout(this.timeout)
-      }
+    const options = {
+      signal: AbortSignal.timeout(this.timeout)
+    }
 
-      const pb = pbStream(stream, {
-        maxDataLength: this.maxMessageSize
-      }).pb(IdentifyMessage)
+    const pb = pbStream(stream, {
+      maxDataLength: this.maxMessageSize
+    }).pb(IdentifyMessage)
 
-      const message = await pb.read(options)
-      await stream.close(options)
+    const message = await pb.read(options)
+    await stream.close(options)
 
-      await consumeIdentifyMessage(this.peerStore, this.events, this.log, connection, message)
-    } catch (err: any) {
-      this.log.error('received invalid message', err)
-      stream.abort(err)
-      return
-    }
+    await consumeIdentifyMessage(this.components.peerStore, this.components.events, log, connection, message)
 
-    this.log.trace('handled push from %p', connection.remotePeer)
+    log.trace('handled push from %p', connection.remotePeer)
   }
 }

package/src/identify.ts

@@ -1,12 +1,10 @@
 import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
-import { InvalidMessageError, UnsupportedProtocolError, serviceCapabilities } from '@libp2p/interface'
+import { InvalidMessageError, serviceCapabilities } from '@libp2p/interface'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import { isGlobalUnicast } from '@libp2p/utils/multiaddr/is-global-unicast'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
-import { CODE_IP6, CODE_IP6ZONE, protocols } from '@multiformats/multiaddr'
+import { isGlobalUnicast, isPrivate, pbStream } from '@libp2p/utils'
+import { CODE_IP6, CODE_IP6ZONE, CODE_P2P } from '@multiformats/multiaddr'
 import { IP_OR_DOMAIN, TCP } from '@multiformats/multiaddr-matcher'
-import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import {
   MULTICODEC_IDENTIFY_PROTOCOL_NAME,
@@ -15,7 +13,7 @@ import {
 import { Identify as IdentifyMessage } from './pb/message.js'
 import { AbstractIdentify, consumeIdentifyMessage, defaultValues, getCleanMultiaddr } from './utils.js'
 import type { Identify as IdentifyInterface, IdentifyComponents, IdentifyInit } from './index.js'
-import type { IdentifyResult, AbortOptions, Connection, Stream, Startable, IncomingStreamData } from '@libp2p/interface'
+import type { IdentifyResult, AbortOptions, Connection, Stream, Startable, Logger } from '@libp2p/interface'
 
 export class Identify extends AbstractIdentify implements Startable, IdentifyInterface {
   constructor (components: IdentifyComponents, init: IdentifyInit = {}) {
@@ -30,14 +28,7 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
       components.events.addEventListener('connection:open', (evt) => {
         const connection = evt.detail
         this.identify(connection)
-          .catch(err => {
-            if (err.name === UnsupportedProtocolError.name) {
-              // the remote did not support identify, ignore the error
-              return
-            }
-
-            this.log.error('error during identify trigged by connection:open', err)
-          })
+          .catch(() => {})
       })
     }
   }
@@ -48,6 +39,7 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
 
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<IdentifyMessage> {
     let stream: Stream | undefined
+    let log: Logger | undefined
 
     if (options.signal == null) {
       const signal = AbortSignal.timeout(this.timeout)
@@ -64,17 +56,21 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
         ...options,
         runOnLimitedConnection: this.runOnLimitedConnection
       })
+      log = stream.log.newScope('identify')
 
       const pb = pbStream(stream, {
         maxDataLength: this.maxMessageSize
       }).pb(IdentifyMessage)
 
+      log('read response')
       const message = await pb.read(options)
 
-      await stream.close(options)
+      log('close write')
+      await pb.unwrap().unwrap().close(options)
 
       return message
     } catch (err: any) {
+      log?.error('identify failed - %e', err)
       stream?.abort(err)
       throw err
     }
@@ -89,27 +85,27 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     } = message
 
     if (publicKey == null) {
-      throw new InvalidMessageError('public key was missing from identify message')
+      throw new InvalidMessageError('Public key was missing from identify message')
     }
 
     const key = publicKeyFromProtobuf(publicKey)
     const id = peerIdFromCID(key.toCID())
 
     if (!connection.remotePeer.equals(id)) {
-      throw new InvalidMessageError('identified peer does not match the expected peer')
+      throw new InvalidMessageError('Identified peer does not match the expected peer')
     }
 
-    if (this.peerId.equals(id)) {
-      throw new InvalidMessageError('identified peer is our own peer id?')
+    if (this.components.peerId.equals(id)) {
+      throw new InvalidMessageError('Identified peer is our own peer id?')
     }
 
     // if the observed address is publicly routable, add it to the address
     // manager for verification via AutoNAT
     this.maybeAddObservedAddress(observedAddr)
 
-    this.log('identify completed for peer %p and protocols %o', id, protocols)
+    this.log('completed for peer %p and protocols %o', id, protocols)
 
-    return consumeIdentifyMessage(this.peerStore, this.events, this.log, connection, message)
+    return consumeIdentifyMessage(this.components.peerStore, this.components.events, this.log, connection, message)
   }
 
   private maybeAddObservedAddress (observedAddr: Uint8Array | undefined): void {
@@ -122,7 +118,6 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     this.log.trace('our observed address was %a', cleanObservedAddr)
 
     if (isPrivate(cleanObservedAddr)) {
-      this.log.trace('our observed address was private')
       return
     }
 
@@ -142,61 +137,61 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
     }
 
     this.log.trace('storing the observed address')
-    this.addressManager.addObservedAddr(cleanObservedAddr)
+    this.components.addressManager.addObservedAddr(cleanObservedAddr)
   }
 
   /**
    * Sends the `Identify` response with the Signed Peer Record
    * to the requesting peer over the given `connection`
    */
-  async handleProtocol (data: IncomingStreamData): Promise<void> {
-    const { connection, stream } = data
+  async handleProtocol (stream: Stream, connection: Connection): Promise<void> {
+    const log = stream.log.newScope('identify')
 
     const signal = AbortSignal.timeout(this.timeout)
-
     setMaxListeners(Infinity, signal)
 
-    try {
-      const peerData = await this.peerStore.get(this.peerId)
-      const multiaddrs = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
-      let signedPeerRecord = peerData.peerRecordEnvelope
-
-      if (multiaddrs.length > 0 && signedPeerRecord == null) {
-        const peerRecord = new PeerRecord({
-          peerId: this.peerId,
-          multiaddrs
-        })
-
-        const envelope = await RecordEnvelope.seal(peerRecord, this.privateKey)
-        signedPeerRecord = envelope.marshal().subarray()
-      }
-
-      let observedAddr: Uint8Array | undefined = connection.remoteAddr.bytes
-
-      if (!IP_OR_DOMAIN.matches(connection.remoteAddr)) {
-        observedAddr = undefined
-      }
+    const peerData = await this.components.peerStore.get(this.components.peerId, {
+      signal
+    })
+    const multiaddrs = this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(CODE_P2P))
+    let signedPeerRecord = peerData.peerRecordEnvelope
 
-      const pb = pbStream(stream).pb(IdentifyMessage)
-
-      await pb.write({
-        protocolVersion: this.host.protocolVersion,
-        agentVersion: this.host.agentVersion,
-        publicKey: publicKeyToProtobuf(this.privateKey.publicKey),
-        listenAddrs: multiaddrs.map(addr => addr.bytes),
-        signedPeerRecord,
-        observedAddr,
-        protocols: peerData.protocols
-      }, {
-        signal
+    if (multiaddrs.length > 0 && signedPeerRecord == null) {
+      const peerRecord = new PeerRecord({
+        peerId: this.components.peerId,
+        multiaddrs
       })
 
-      await stream.close({
+      const envelope = await RecordEnvelope.seal(peerRecord, this.components.privateKey, {
         signal
       })
-    } catch (err: any) {
-      this.log.error('could not respond to identify request', err)
-      stream.abort(err)
+      signedPeerRecord = envelope.marshal().subarray()
+    }
+
+    let observedAddr: Uint8Array | undefined = connection.remoteAddr.bytes
+
+    if (!IP_OR_DOMAIN.matches(connection.remoteAddr)) {
+      observedAddr = undefined
     }
+
+    const pb = pbStream(stream).pb(IdentifyMessage)
+
+    log('send response')
+    await pb.write({
+      protocolVersion: this.host.protocolVersion,
+      agentVersion: this.host.agentVersion,
+      publicKey: publicKeyToProtobuf(this.components.privateKey.publicKey),
+      listenAddrs: multiaddrs.map(addr => addr.bytes),
+      signedPeerRecord,
+      observedAddr,
+      protocols: peerData.protocols
+    }, {
+      signal
+    })
+
+    log('close write')
+    await pb.unwrap().unwrap().close({
+      signal
+    })
   }
 }

package/src/index.ts

@@ -55,13 +55,6 @@ export interface IdentifyInit {
    */
   protocolPrefix?: string
 
-  /**
-   * What details we should send as part of an identify message
-   *
-   * @deprecated Use `nodeInfo.userAgent` in the main libp2p config instead
-   */
-  agentVersion?: string
-
   /**
    * How long we should wait for a remote peer to send their identify response
    *

package/src/utils.ts

@@ -7,8 +7,7 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { IDENTIFY_PROTOCOL_VERSION, MAX_IDENTIFY_MESSAGE_SIZE, MAX_PUSH_CONCURRENCY } from './consts.js'
 import type { IdentifyComponents, IdentifyInit } from './index.js'
 import type { Identify as IdentifyMessage } from './pb/message.js'
-import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, Logger, Connection, Peer, PeerData, PeerStore, NodeInfo, Startable, PeerId, IncomingStreamData, PrivateKey } from '@libp2p/interface'
-import type { AddressManager, Registrar } from '@libp2p/interface-internal'
+import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, Logger, Connection, Peer, PeerData, PeerStore, Startable, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -38,14 +37,6 @@ export function getCleanMultiaddr (addr: Uint8Array | string | null | undefined)
   }
 }
 
-export function getAgentVersion (nodeInfo: NodeInfo, agentVersion?: string): string {
-  if (agentVersion != null) {
-    return agentVersion
-  }
-
-  return nodeInfo.userAgent
-}
-
 export async function consumeIdentifyMessage (peerStore: PeerStore, events: TypedEventTarget<Libp2pEvents>, log: Logger, connection: Connection, message: IdentifyMessage): Promise<IdentifyResult> {
   log('received identify from %p', connection.remotePeer)
 
@@ -191,31 +182,21 @@ export abstract class AbstractIdentify implements Startable {
     agentVersion: string
   }
 
+  protected components: IdentifyComponents
   protected protocol: string
   protected started: boolean
   protected readonly timeout: number
-  protected readonly peerId: PeerId
-  protected readonly privateKey: PrivateKey
-  protected readonly peerStore: PeerStore
-  protected readonly registrar: Registrar
-  protected readonly addressManager: AddressManager
   private readonly maxInboundStreams: number
   private readonly maxOutboundStreams: number
   protected readonly maxMessageSize: number
   protected readonly maxObservedAddresses: number
-  protected readonly events: TypedEventTarget<Libp2pEvents>
   protected readonly runOnLimitedConnection: boolean
   protected readonly log: Logger
 
   constructor (components: IdentifyComponents, init: AbstractIdentifyInit) {
     this.protocol = init.protocol
     this.started = false
-    this.peerId = components.peerId
-    this.privateKey = components.privateKey
-    this.peerStore = components.peerStore
-    this.registrar = components.registrar
-    this.addressManager = components.addressManager
-    this.events = components.events
+    this.components = components
     this.log = init.log
 
     this.timeout = init.timeout ?? defaultValues.timeout
@@ -228,8 +209,10 @@ export abstract class AbstractIdentify implements Startable {
     // Store self host metadata
     this.host = {
       protocolVersion: `${init.protocolPrefix ?? defaultValues.protocolPrefix}/${IDENTIFY_PROTOCOL_VERSION}`,
-      agentVersion: getAgentVersion(components.nodeInfo, init.agentVersion)
+      agentVersion: components.nodeInfo.userAgent
     }
+
+    this.handleProtocol = this.handleProtocol.bind(this)
   }
 
   isStarted (): boolean {
@@ -241,18 +224,14 @@ export abstract class AbstractIdentify implements Startable {
       return
     }
 
-    await this.peerStore.merge(this.peerId, {
+    await this.components.peerStore.merge(this.components.peerId, {
       metadata: {
         AgentVersion: uint8ArrayFromString(this.host.agentVersion),
         ProtocolVersion: uint8ArrayFromString(this.host.protocolVersion)
       }
     })
 
-    await this.registrar.handle(this.protocol, (data) => {
-      void this.handleProtocol(data).catch(err => {
-        this.log.error(err)
-      })
-    }, {
+    await this.components.registrar.handle(this.protocol, this.handleProtocol, {
       maxInboundStreams: this.maxInboundStreams,
       maxOutboundStreams: this.maxOutboundStreams,
       runOnLimitedConnection: this.runOnLimitedConnection
@@ -262,10 +241,10 @@ export abstract class AbstractIdentify implements Startable {
   }
 
   async stop (): Promise<void> {
-    await this.registrar.unhandle(this.protocol)
+    await this.components.registrar.unhandle(this.protocol)
 
     this.started = false
   }
 
-  protected abstract handleProtocol (data: IncomingStreamData): Promise<void>
+  protected abstract handleProtocol (stream: Stream, connection: Connection): Promise<void>
 }

package/dist/typedoc-urls.json

@@ -1,18 +0,0 @@
-{
-  "Identify": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.Identify.html",
-  ".:Identify": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.Identify.html",
-  "IdentifyComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyComponents.html",
-  ".:IdentifyComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyComponents.html",
-  "IdentifyInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyInit.html",
-  ".:IdentifyInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyInit.html",
-  "IdentifyPush": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPush.html",
-  ".:IdentifyPush": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPush.html",
-  "IdentifyPushComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushComponents.html",
-  ".:IdentifyPushComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushComponents.html",
-  "IdentifyPushInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushInit.html",
-  ".:IdentifyPushInit": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_identify.IdentifyPushInit.html",
-  "identify": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identify.html",
-  ".:identify": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identify.html",
-  "identifyPush": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identifyPush.html",
-  ".:identifyPush": "https://libp2p.github.io/js-libp2p/functions/_libp2p_identify.identifyPush.html"
-}