@libp2p/identify 3.0.38-cf9aab5c8 → 3.0.39-0f07e3df5

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,22 +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 log = connection.log.newScope('identify-push')
+          const peer = await self.components.peerStore.get(connection.remotePeer)
 
           if (!peer.protocols.includes(self.protocol)) {
             continue
@@ -115,8 +113,9 @@ export class IdentifyPush extends AbstractIdentify implements Startable, Identif
                 signal
               })
             } catch (err: any) {
-              // Just log errors
-              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)
             }
           }
@@ -134,32 +133,25 @@ 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
-    const log = connection.log.newScope('identify-push')
+  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, log, connection, message)
-    } catch (err: any) {
-      log.error('received invalid message', err)
-      stream.abort(err)
-      return
-    }
+    await consumeIdentifyMessage(this.components.peerStore, this.components.events, log, connection, message)
 
     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, Logger } 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
     }
@@ -94,43 +90,41 @@ 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.peerId.equals(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, log)
+    this.maybeAddObservedAddress(observedAddr)
 
-    log('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, log, connection, message)
+    return consumeIdentifyMessage(this.components.peerStore, this.components.events, this.log, connection, message)
   }
 
-  private maybeAddObservedAddress (observedAddr: Uint8Array | undefined, log: Logger): void {
+  private maybeAddObservedAddress (observedAddr: Uint8Array | undefined): void {
     const cleanObservedAddr = getCleanMultiaddr(observedAddr)
 
     if (cleanObservedAddr == null) {
       return
     }
 
-    log.trace('our observed address was %a', cleanObservedAddr)
+    this.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)) {
-      log.trace('our observed address was IPv6 but not a global unicast address')
+      this.log.trace('our observed address was IPv6 but not a global unicast address')
       return
     }
 
@@ -142,63 +136,62 @@ export class Identify extends AbstractIdentify implements Startable, IdentifyInt
       return
     }
 
-    log.trace('storing the observed address')
-    this.addressManager.addObservedAddr(cleanObservedAddr)
+    this.log.trace('storing the observed address')
+    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
-    const log = connection.log.newScope('identify')
+  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) {
-      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/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, NodeInfo, Startable, Stream } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -191,31 +190,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
@@ -230,6 +219,8 @@ 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 {
@@ -241,18 +232,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 +249,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>
 }