@libp2p/identify 3.0.39-8484de8a2 → 3.0.39-87bc8d4fb

package/src/identify-push.ts

@@ -1,9 +1,10 @@
 import { serviceCapabilities } from '@libp2p/interface'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import { debounce, pbStream } from '@libp2p/utils'
-import { CODE_P2P } from '@multiformats/multiaddr'
+import { debounce } from '@libp2p/utils/debounce'
+import { protocols } 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'
@@ -15,7 +16,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, Connection } from '@libp2p/interface'
+import type { Stream, Startable, IncomingStreamData } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 
 export class IdentifyPush extends AbstractIdentify implements Startable, IdentifyPushInterface {
@@ -63,21 +64,22 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
     }
 
     try {
-      const listenAddresses = this.components.addressManager.getAddresses().map(ma => ma.decapsulateCode(CODE_P2P))
+      const listenAddresses = this.addressManager.getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
       const peerRecord = new PeerRecord({
-        peerId: this.components.peerId,
+        peerId: this.peerId,
         multiaddrs: listenAddresses
       })
-      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 signedPeerRecord = await RecordEnvelope.seal(peerRecord, this.privateKey)
+      const supportedProtocols = this.registrar.getProtocols()
+      const peer = await this.peerStore.get(this.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.components.peerStore.get(connection.remotePeer)
+          const peer = await self.peerStore.get(connection.remotePeer)
+          const log = connection.log.newScope('identify-push')
 
           if (!peer.protocols.includes(self.protocol)) {
             continue
@@ -113,9 +115,8 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
                 signal
               })
             } catch (err: any) {
-              // 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)
+              // Just log errors
+              log.error('could not push identify update to peer', err)
               stream?.abort(err)
             }
           }
@@ -133,25 +134,32 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
   /**
    * Reads the Identify Push message from the given `connection`
    */
-  async handleProtocol (stream: Stream, connection: Connection): Promise<void> {
-    const log = stream.log.newScope('identify-push')
+  async handleProtocol (data: IncomingStreamData): Promise<void> {
+    const { connection, stream } = data
+    const log = connection.log.newScope('identify-push')
 
-    if (this.components.peerId.equals(connection.remotePeer)) {
-      throw new Error('received push from ourselves?')
-    }
+    try {
+      if (this.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.components.peerStore, this.components.events, log, connection, message)
+      await consumeIdentifyMessage(this.peerStore, this.events, log, connection, message)
+    } catch (err: any) {
+      log.error('received invalid message', err)
+      stream.abort(err)
+      return
+    }
 
     log.trace('handled push from %p', connection.remotePeer)
   }

package/src/identify.ts

@@ -1,10 +1,12 @@
 import { publicKeyFromProtobuf, publicKeyToProtobuf } from '@libp2p/crypto/keys'
-import { InvalidMessageError, serviceCapabilities } from '@libp2p/interface'
+import { InvalidMessageError, UnsupportedProtocolError, serviceCapabilities } from '@libp2p/interface'
 import { peerIdFromCID } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
-import { isGlobalUnicast, isPrivate, pbStream } from '@libp2p/utils'
-import { CODE_IP6, CODE_IP6ZONE, CODE_P2P } from '@multiformats/multiaddr'
+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 { IP_OR_DOMAIN, TCP } from '@multiformats/multiaddr-matcher'
+import { pbStream } from 'it-protobuf-stream'
 import { setMaxListeners } from 'main-event'
 import {
   MULTICODEC_IDENTIFY_PROTOCOL_NAME,
@@ -13,7 +15,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, Logger } from '@libp2p/interface'
+import type { IdentifyResult, AbortOptions, Connection, Stream, Startable, IncomingStreamData, Logger } from '@libp2p/interface'
 
 export class Identify extends AbstractIdentify implements Startable, IdentifyInterface {
   constructor (components: IdentifyComponents, init: IdentifyInit = {}) {
@@ -28,7 +30,14 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
       components.events.addEventListener('connection:open', (evt) => {
         const connection = evt.detail
         this.identify(connection)
-          .catch(() => {})
+          .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)
+          })
       })
     }
   }
@@ -39,7 +48,6 @@ 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)
@@ -56,21 +64,17 @@ 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)
 
-      log('close write')
-      await pb.unwrap().unwrap().close(options)
+      await stream.close(options)
 
       return message
     } catch (err: any) {
-      log?.error('identify failed - %e', err)
       stream?.abort(err)
       throw err
     }
@@ -90,41 +94,43 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
 
     const key = publicKeyFromProtobuf(publicKey)
     const id = peerIdFromCID(key.toCID())
+    const log = connection.log.newScope('identify')
 
     if (!connection.remotePeer.equals(id)) {
       throw new InvalidMessageError('Identified peer does not match the expected peer')
     }
 
-    if (this.components.peerId.equals(id)) {
+    if (this.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.maybeAddObservedAddress(observedAddr, log)
 
-    this.log('completed for peer %p and protocols %o', id, protocols)
+    log('completed for peer %p and protocols %o', id, protocols)
 
-    return consumeIdentifyMessage(this.components.peerStore, this.components.events, this.log, connection, message)
+    return consumeIdentifyMessage(this.peerStore, this.events, log, connection, message)
   }
 
-  private maybeAddObservedAddress (observedAddr: Uint8Array | undefined): void {
+  private maybeAddObservedAddress (observedAddr: Uint8Array | undefined, log: Logger): void {
     const cleanObservedAddr = getCleanMultiaddr(observedAddr)
 
     if (cleanObservedAddr == null) {
       return
     }
 
-    this.log.trace('our observed address was %a', cleanObservedAddr)
+    log.trace('our observed address was %a', cleanObservedAddr)
 
     if (isPrivate(cleanObservedAddr)) {
+      this.log.trace('our observed address was private')
       return
     }
 
     const tuples = cleanObservedAddr.getComponents()
 
     if (((tuples[0].code === CODE_IP6) || (tuples[0].code === CODE_IP6ZONE && tuples[1].code === CODE_IP6)) && !isGlobalUnicast(cleanObservedAddr)) {
-      this.log.trace('our observed address was IPv6 but not a global unicast address')
+      log.trace('our observed address was IPv6 but not a global unicast address')
       return
     }
 
@@ -136,62 +142,63 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
       return
     }
 
-    this.log.trace('storing the observed address')
-    this.components.addressManager.addObservedAddr(cleanObservedAddr)
+    log.trace('storing the observed address')
+    this.addressManager.addObservedAddr(cleanObservedAddr)
   }
 
   /**
    * Sends the `Identify` response with the Signed Peer Record
    * to the requesting peer over the given `connection`
    */
-  async handleProtocol (stream: Stream, connection: Connection): Promise<void> {
-    const log = stream.log.newScope('identify')
+  async handleProtocol (data: IncomingStreamData): Promise<void> {
+    const { connection, stream } = data
+    const log = connection.log.newScope('identify')
 
     const signal = AbortSignal.timeout(this.timeout)
+
     setMaxListeners(Infinity, signal)
 
-    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
+    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()
+      }
 
-    if (multiaddrs.length > 0 && signedPeerRecord == null) {
-      const peerRecord = new PeerRecord({
-        peerId: this.components.peerId,
-        multiaddrs
-      })
+      let observedAddr: Uint8Array | undefined = connection.remoteAddr.bytes
+
+      if (!IP_OR_DOMAIN.matches(connection.remoteAddr)) {
+        observedAddr = undefined
+      }
 
-      const envelope = await RecordEnvelope.seal(peerRecord, this.components.privateKey, {
+      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
       })
-      signedPeerRecord = envelope.marshal().subarray()
-    }
 
-    let observedAddr: Uint8Array | undefined = connection.remoteAddr.bytes
-
-    if (!IP_OR_DOMAIN.matches(connection.remoteAddr)) {
-      observedAddr = undefined
+      await stream.close({
+        signal
+      })
+    } catch (err: any) {
+      log.error('could not respond to identify request', err)
+      stream.abort(err)
     }
-
-    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/utils.ts

@@ -7,7 +7,8 @@ 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, Stream } from '@libp2p/interface'
+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 { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -190,21 +191,31 @@ 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.components = components
+    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.log = init.log
 
     this.timeout = init.timeout ?? defaultValues.timeout
@@ -219,8 +230,6 @@ export abstract class AbstractIdentify implements Startable {
       protocolVersion: `${init.protocolPrefix ?? defaultValues.protocolPrefix}/${IDENTIFY_PROTOCOL_VERSION}`,
       agentVersion: getAgentVersion(components.nodeInfo, init.agentVersion)
     }
-
-    this.handleProtocol = this.handleProtocol.bind(this)
   }
 
   isStarted (): boolean {
@@ -232,14 +241,18 @@ export abstract class AbstractIdentify implements Startable {
       return
     }
 
-    await this.components.peerStore.merge(this.components.peerId, {
+    await this.peerStore.merge(this.peerId, {
       metadata: {
         AgentVersion: uint8ArrayFromString(this.host.agentVersion),
         ProtocolVersion: uint8ArrayFromString(this.host.protocolVersion)
       }
     })
 
-    await this.components.registrar.handle(this.protocol, this.handleProtocol, {
+    await this.registrar.handle(this.protocol, (data) => {
+      void this.handleProtocol(data).catch(err => {
+        this.log.error(err)
+      })
+    }, {
       maxInboundStreams: this.maxInboundStreams,
       maxOutboundStreams: this.maxOutboundStreams,
       runOnLimitedConnection: this.runOnLimitedConnection
@@ -249,10 +262,10 @@ export abstract class AbstractIdentify implements Startable {
   }
 
   async stop (): Promise<void> {
-    await this.components.registrar.unhandle(this.protocol)
+    await this.registrar.unhandle(this.protocol)
 
     this.started = false
   }
 
-  protected abstract handleProtocol (stream: Stream, connection: Connection): Promise<void>
+  protected abstract handleProtocol (data: IncomingStreamData): Promise<void>
 }