libp2p 0.45.9 → 0.46.0

package/src/connection-manager/index.ts

@@ -1,5 +1,5 @@
-import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { KEEP_ALIVE } from '@libp2p/interface/peer-store/tags'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
@@ -12,17 +12,16 @@ import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
 import { DialQueue } from './dial-queue.js'
-import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PendingDial, AddressSorter, Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Peer, PeerStore } from '@libp2p/interface-peer-store'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Peer, PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:connection-manager')
 
@@ -274,7 +273,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
         for (const conns of this.connections.values()) {
           for (const conn of conns) {
-            if (conn.stat.direction === 'inbound') {
+            if (conn.direction === 'inbound') {
               metric.inbound++
             } else {
               metric.outbound++
@@ -295,7 +294,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
         for (const conns of this.connections.values()) {
           for (const conn of conns) {
             for (const stream of conn.streams) {
-              const key = `${stream.stat.direction} ${stream.stat.protocol ?? 'unnegotiated'}`
+              const key = `${stream.direction} ${stream.protocol ?? 'unnegotiated'}`
 
               metric[key] = (metric[key] ?? 0) + 1
             }
@@ -317,7 +316,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
             const streams: Record<string, number> = {}
 
             for (const stream of conn.streams) {
-              const key = `${stream.stat.direction} ${stream.stat.protocol ?? 'unnegotiated'}`
+              const key = `${stream.direction} ${stream.protocol ?? 'unnegotiated'}`
 
               streams[key] = (streams[key] ?? 0) + 1
             }
@@ -489,6 +488,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
     }
 
+    options.signal?.throwIfAborted()
+
     const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId != null) {
@@ -531,12 +532,16 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     return connection
   }
 
-  async closeConnections (peerId: PeerId): Promise<void> {
+  async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {
     const connections = this.connections.get(peerId) ?? []
 
     await Promise.all(
       connections.map(async connection => {
-        await connection.close()
+        try {
+          await connection.close(options)
+        } catch (err: any) {
+          connection.abort(err)
+        }
       })
     )
   }
@@ -548,7 +553,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     })
 
     if (denyConnection) {
-      log('connection from %s refused - connection remote address was in deny list', maConn.remoteAddr)
+      log('connection from %a refused - connection remote address was in deny list', maConn.remoteAddr)
       return false
     }
 
@@ -565,7 +570,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check pending connections
     if (this.incomingPendingConnections === this.maxIncomingPendingConnections) {
-      log('connection from %s refused - incomingPendingConnections exceeded by peer %s', maConn.remoteAddr)
+      log('connection from %a refused - incomingPendingConnections exceeded by host', maConn.remoteAddr)
       return false
     }
 
@@ -575,7 +580,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       try {
         await this.inboundConnectionRateLimiter.consume(host, 1)
       } catch {
-        log('connection from %s refused - inboundConnectionThreshold exceeded by host %s', host, maConn.remoteAddr)
+        log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
         return false
       }
     }
@@ -586,7 +591,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return true
     }
 
-    log('connection from %s refused - maxConnections exceeded', maConn.remoteAddr)
+    log('connection from %a refused - maxConnections exceeded', maConn.remoteAddr)
     return false
   }
 

package/src/content-routing/index.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import merge from 'it-merge'
 import { pipe } from 'it-pipe'
 import { messages, codes } from '../errors.js'
@@ -7,11 +7,11 @@ import {
   uniquePeers,
   requirePeers
 } from './utils.js'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { AbortOptions } from '@libp2p/interface'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
 import type { CID } from 'multiformats/cid'
 
 export interface CompoundContentRoutingInit {

package/src/content-routing/utils.ts

@@ -1,8 +1,8 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import filter from 'it-filter'
 import map from 'it-map'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerStore } from '@libp2p/interface/peer-store'
 import type { Source } from 'it-stream-types'
 
 /**

package/src/fetch/constants.ts

@@ -1,4 +1,3 @@
-
 // https://github.com/libp2p/specs/tree/master/fetch#wire-protocol
 export const PROTOCOL_VERSION = '0.0.1'
 export const PROTOCOL_NAME = 'fetch'

package/src/fetch/index.ts

@@ -1,5 +1,5 @@
 import { setMaxListeners } from 'events'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { abortableDuplex } from 'abortable-iterator'
 import first from 'it-first'
@@ -10,12 +10,12 @@ import { toString as uint8arrayToString } from 'uint8arrays/to-string'
 import { codes } from '../errors.js'
 import { PROTOCOL_NAME, PROTOCOL_VERSION } from './constants.js'
 import { FetchRequest, FetchResponse } from './pb/proto.js'
-import type { Stream } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { AbortOptions } from '@libp2p/interface'
+import type { Stream } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
 
 const log = logger('libp2p:fetch')
 
@@ -109,12 +109,12 @@ class DefaultFetchService implements Startable, FetchService {
   async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleMessage(data)
+        .then(async () => {
+          await data.stream.close()
+        })
         .catch(err => {
           log.error(err)
         })
-        .finally(() => {
-          data.stream.close()
-        })
     }, {
       maxInboundStreams: this.init.maxInboundStreams,
       maxOutboundStreams: this.init.maxOutboundStreams
@@ -201,7 +201,7 @@ class DefaultFetchService implements Startable, FetchService {
       return result ?? null
     } finally {
       if (stream != null) {
-        stream.close()
+        await stream.close()
       }
     }
   }

package/src/get-peer.ts

@@ -1,10 +1,10 @@
-import { isPeerId } from '@libp2p/interface-peer-id'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { isPeerId } from '@libp2p/interface/peer-id'
 import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isMultiaddr } from '@multiformats/multiaddr'
 import { codes } from './errors.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:get-peer')

package/src/identify/consts.ts

@@ -1,4 +1,3 @@
-
 import { version } from '../version.js'
 
 export const PROTOCOL_VERSION = 'ipfs/0.1.0' // deprecated

package/src/identify/identify.ts

@@ -1,15 +1,10 @@
 import { setMaxListeners } from 'events'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { peerIdFromKeys } from '@libp2p/peer-id'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
 import { type Multiaddr, multiaddr, protocols } from '@multiformats/multiaddr'
-import { abortableDuplex } from 'abortable-iterator'
-import { anySignal } from 'any-signal'
-import first from 'it-first'
-import * as lp from 'it-length-prefixed'
-import { pbStream } from 'it-pb-stream'
-import { pipe } from 'it-pipe'
+import { pbStream } from 'it-protobuf-stream'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { isNode, isBrowser, isWebWorker, isElectronMain, isElectronRenderer, isReactNative } from 'wherearewe'
@@ -23,17 +18,16 @@ import {
   MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } from './consts.js'
 import { Identify } from './pb/message.js'
-import type { IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents, IdentifyResult, SignedPeerRecord } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Peer, PeerStore } from '@libp2p/interface-peer-store'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { IdentifyService, IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
+import type { Libp2pEvents, IdentifyResult, SignedPeerRecord, AbortOptions } from '@libp2p/interface'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Peer, PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
 
 const log = logger('libp2p:identify')
 
@@ -50,10 +44,12 @@ const defaultValues = {
   maxPushIncomingStreams: 1,
   maxPushOutgoingStreams: 1,
   maxObservedAddresses: 10,
-  maxIdentifyMessageSize: 8192
+  maxIdentifyMessageSize: 8192,
+  runOnConnectionOpen: true,
+  runOnTransientConnection: true
 }
 
-export class DefaultIdentifyService implements Startable {
+export class DefaultIdentifyService implements Startable, IdentifyService {
   private readonly identifyProtocolStr: string
   private readonly identifyPushProtocolStr: string
   public readonly host: {
@@ -75,6 +71,7 @@ export class DefaultIdentifyService implements Startable {
   private readonly maxIdentifyMessageSize: number
   private readonly maxObservedAddresses: number
   private readonly events: EventEmitter<Libp2pEvents>
+  private readonly runOnTransientConnection: boolean
 
   constructor (components: IdentifyServiceComponents, init: IdentifyServiceInit) {
     this.started = false
@@ -94,6 +91,7 @@ export class DefaultIdentifyService implements Startable {
     this.maxPushOutgoingStreams = init.maxPushOutgoingStreams ?? defaultValues.maxPushOutgoingStreams
     this.maxIdentifyMessageSize = init.maxIdentifyMessageSize ?? defaultValues.maxIdentifyMessageSize
     this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
+    this.runOnTransientConnection = init.runOnTransientConnection ?? defaultValues.runOnTransientConnection
 
     // Store self host metadata
     this.host = {
@@ -101,11 +99,13 @@ export class DefaultIdentifyService implements Startable {
       agentVersion: init.agentVersion ?? defaultValues.agentVersion
     }
 
-    // When a new connection happens, trigger identify
-    components.events.addEventListener('connection:open', (evt) => {
-      const connection = evt.detail
-      this.identify(connection).catch(err => { log.error('error during identify trigged by connection:open', err) })
-    })
+    if (init.runOnConnectionOpen ?? defaultValues.runOnConnectionOpen) {
+      // When a new connection happens, trigger identify
+      components.events.addEventListener('connection:open', (evt) => {
+        const connection = evt.detail
+        this.identify(connection).catch(err => { log.error('error during identify trigged by connection:open', err) })
+      })
+    }
 
     // When self peer record changes, trigger identify-push
     components.events.addEventListener('self:peer:update', (evt) => {
@@ -144,7 +144,8 @@ export class DefaultIdentifyService implements Startable {
       })
     }, {
       maxInboundStreams: this.maxInboundStreams,
-      maxOutboundStreams: this.maxOutboundStreams
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnTransientConnection: this.runOnTransientConnection
     })
     await this.registrar.handle(this.identifyPushProtocolStr, (data) => {
       void this._handlePush(data).catch(err => {
@@ -152,7 +153,8 @@ export class DefaultIdentifyService implements Startable {
       })
     }, {
       maxInboundStreams: this.maxPushIncomingStreams,
-      maxOutboundStreams: this.maxPushOutgoingStreams
+      maxOutboundStreams: this.maxPushOutgoingStreams,
+      runOnTransientConnection: this.runOnTransientConnection
     })
 
     this.started = true
@@ -192,29 +194,31 @@ export class DefaultIdentifyService implements Startable {
 
       try {
         stream = await connection.newStream([this.identifyPushProtocolStr], {
+          signal,
+          runOnTransientConnection: this.runOnTransientConnection
+        })
+
+        const pb = pbStream(stream, {
+          maxDataLength: this.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
+        }).pb(Identify)
+
+        await pb.write({
+          listenAddrs: listenAddresses.map(ma => ma.bytes),
+          signedPeerRecord: signedPeerRecord.marshal(),
+          protocols: supportedProtocols,
+          agentVersion,
+          protocolVersion
+        }, {
           signal
         })
 
-        // make stream abortable
-        const source = abortableDuplex(stream, signal)
-
-        await source.sink(pipe(
-          [Identify.encode({
-            listenAddrs: listenAddresses.map(ma => ma.bytes),
-            signedPeerRecord: signedPeerRecord.marshal(),
-            protocols: supportedProtocols,
-            agentVersion,
-            protocolVersion
-          })],
-          (source) => lp.encode(source)
-        ))
+        await stream.close({
+          signal
+        })
       } catch (err: any) {
         // Just log errors
         log.error('could not push identify update to peer', err)
-      } finally {
-        if (stream != null) {
-          stream.close()
-        }
+        stream?.abort(err)
       }
     })
 
@@ -256,48 +260,31 @@ export class DefaultIdentifyService implements Startable {
   async _identify (connection: Connection, options: AbortOptions = {}): Promise<Identify> {
     let stream: Stream | undefined
 
-    const signal = anySignal([AbortSignal.timeout(this.timeout), options?.signal])
-
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, signal)
-    } catch {}
+    options.signal = options.signal ?? AbortSignal.timeout(this.timeout)
 
     try {
       stream = await connection.newStream([this.identifyProtocolStr], {
-        signal
+        ...options,
+        runOnTransientConnection: this.runOnTransientConnection
       })
 
-      // make stream abortable
-      const source = abortableDuplex(stream, signal)
+      const pb = pbStream(stream, {
+        maxDataLength: this.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
+      }).pb(Identify)
 
-      const data = await pipe(
-        [],
-        source,
-        (source) => lp.decode(source, {
-          maxDataLength: this.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
-        }),
-        async (source) => first(source)
-      )
+      const message = await pb.read(options)
 
-      if (data == null) {
-        throw new CodeError('No data could be retrieved', codes.ERR_CONNECTION_ENDED)
-      }
+      await stream.close(options)
 
-      try {
-        return Identify.decode(data)
-      } catch (err: any) {
-        throw new CodeError(String(err), codes.ERR_INVALID_MESSAGE)
-      }
-    } finally {
-      if (stream != null) {
-        stream.close()
-      }
-      signal.clear()
+      return message
+    } catch (err: any) {
+      log.error('error while reading identify message', err)
+      stream?.abort(err)
+      throw err
     }
   }
 
-  async identify (connection: Connection, options: AbortOptions = {}): Promise<void> {
+  async identify (connection: Connection, options: AbortOptions = {}): Promise<IdentifyResult> {
     const message = await this._identify(connection, options)
     const {
       publicKey,
@@ -323,11 +310,11 @@ export class DefaultIdentifyService implements Startable {
     const cleanObservedAddr = getCleanMultiaddr(observedAddr)
 
     log('identify completed for peer %p and protocols %o', id, protocols)
-    log('our observed address is %s', cleanObservedAddr)
+    log('our observed address is %a', cleanObservedAddr)
 
     if (cleanObservedAddr != null &&
         this.addressManager.getObservedAddrs().length < (this.maxObservedAddresses ?? Infinity)) {
-      log('storing our observed address %s', cleanObservedAddr?.toString())
+      log('storing our observed address %a', cleanObservedAddr)
       this.addressManager.addObservedAddr(cleanObservedAddr)
     }
 
@@ -345,6 +332,8 @@ export class DefaultIdentifyService implements Startable {
     }
 
     this.events.safeDispatchEvent('peer:identify', { detail: result })
+
+    return result
   }
 
   /**
@@ -377,7 +366,9 @@ export class DefaultIdentifyService implements Startable {
         signedPeerRecord = envelope.marshal().subarray()
       }
 
-      const message = Identify.encode({
+      const pb = pbStream(stream).pb(Identify)
+
+      await pb.write({
         protocolVersion: this.host.protocolVersion,
         agentVersion: this.host.agentVersion,
         publicKey,
@@ -385,17 +376,16 @@ export class DefaultIdentifyService implements Startable {
         signedPeerRecord,
         observedAddr: connection.remoteAddr.bytes,
         protocols: peerData.protocols
+      }, {
+        signal
       })
 
-      // make stream abortable
-      const source = abortableDuplex(stream, signal)
-
-      const msgWithLenPrefix = pipe([message], (source) => lp.encode(source))
-      await source.sink(msgWithLenPrefix)
+      await stream.close({
+        signal
+      })
     } catch (err: any) {
       log.error('could not respond to identify request', err)
-    } finally {
-      stream.close()
+      stream.abort(err)
     }
   }
 
@@ -410,19 +400,22 @@ export class DefaultIdentifyService implements Startable {
         throw new Error('received push from ourselves?')
       }
 
-      // make stream abortable
-      const source = abortableDuplex(stream, AbortSignal.timeout(this.timeout))
-      const pb = pbStream(source, {
+      const options = {
+        signal: AbortSignal.timeout(this.timeout)
+      }
+
+      const pb = pbStream(stream, {
         maxDataLength: this.maxIdentifyMessageSize ?? MAX_IDENTIFY_MESSAGE_SIZE
-      })
-      const message = await pb.readPB(Identify)
+      }).pb(Identify)
+
+      const message = await pb.read(options)
+      await stream.close(options)
 
       await this.#consumeIdentifyMessage(connection.remotePeer, message)
     } catch (err: any) {
       log.error('received invalid message', err)
+      stream.abort(err)
       return
-    } finally {
-      stream.close()
     }
 
     log('handled push from %p', connection.remotePeer)

package/src/identify/index.ts

@@ -4,13 +4,14 @@ import {
 } from './consts.js'
 import { DefaultIdentifyService } from './identify.js'
 import { Identify } from './pb/message.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Registrar } from '@libp2p/interface-registrar'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { AbortOptions, IdentifyResult, Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Connection } from '@libp2p/interface/src/connection/index.js'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
 
 export interface IdentifyServiceInit {
   /**
@@ -39,6 +40,16 @@ export interface IdentifyServiceInit {
   maxPushIncomingStreams?: number
   maxPushOutgoingStreams?: number
   maxObservedAddresses?: number
+
+  /**
+   * Whether to automatically dial identify on newly opened connections (default: true)
+   */
+  runOnConnectionOpen?: boolean
+
+  /**
+   * Whether to run on connections with data or duration limits (default: true)
+   */
+  runOnTransientConnection?: boolean
 }
 
 export interface IdentifyServiceComponents {
@@ -60,6 +71,19 @@ export const multicodecs = {
 
 export const Message = { Identify }
 
-export function identifyService (init: IdentifyServiceInit = {}): (components: IdentifyServiceComponents) => DefaultIdentifyService {
+export interface IdentifyService {
+  /**
+   * due to the default limits on inbound/outbound streams for this protocol,
+   * invoking this method when runOnConnectionOpen is true can lead to unpredictable results
+   * as streams may be closed by the local or the remote node.
+   * Please use with caution. If you find yourself needing to call this method to discover other peers that support your protocol,
+   * you may be better off configuring a topology to be notified instead.
+   */
+  identify: (connection: Connection, options?: AbortOptions) => Promise<IdentifyResult>
+
+  push: () => Promise<void>
+}
+
+export function identifyService (init: IdentifyServiceInit = {}): (components: IdentifyServiceComponents) => IdentifyService {
   return (components) => new DefaultIdentifyService(components, init)
 }

package/src/index.ts

@@ -19,18 +19,17 @@ import type { AddressManagerInit } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { TransportManagerInit } from './transport-manager.js'
-import type { ConnectionProtector } from '@libp2p/interface-connection'
-import type { ConnectionEncrypter } from '@libp2p/interface-connection-encrypter'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Libp2p, ServiceMap } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { PeerDiscovery } from '@libp2p/interface-peer-discovery'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
-import type { Transport } from '@libp2p/interface-transport'
-import type { RecursivePartial } from '@libp2p/interfaces'
+import type { Libp2p, ServiceMap, RecursivePartial } from '@libp2p/interface'
+import type { ConnectionProtector } from '@libp2p/interface/connection'
+import type { ConnectionEncrypter } from '@libp2p/interface/connection-encrypter'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerDiscovery } from '@libp2p/interface/peer-discovery'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerRouting } from '@libp2p/interface/peer-routing'
+import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { Transport } from '@libp2p/interface/transport'
 import type { KeyChainInit } from '@libp2p/keychain'
 import type { PersistentPeerStoreInit } from '@libp2p/peer-store'
 import type { Datastore } from 'interface-datastore'