libp2p 0.45.9-daeb43d8 → 0.45.9-e9cafd3d

package/src/connection/index.ts

@@ -1,9 +1,9 @@
-import { symbol } from '@libp2p/interface/connection'
+import { type Direction, symbol, type Connection, type Stream, type ConnectionTimeline } from '@libp2p/interface/connection'
 import { OPEN, CLOSING, CLOSED } from '@libp2p/interface/connection/status'
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interface'
-import type { Connection, ConnectionStat, Stream } from '@libp2p/interface/connection'
+import type * as Status from '@libp2p/interface/connection/status'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
@@ -15,7 +15,11 @@ interface ConnectionInit {
   newStream: (protocols: string[], options?: AbortOptions) => Promise<Stream>
   close: () => Promise<void>
   getStreams: () => Stream[]
-  stat: ConnectionStat
+  status: keyof typeof Status
+  direction: Direction
+  timeline: ConnectionTimeline
+  multiplexer?: string
+  encryption?: string
 }
 
 /**
@@ -38,10 +42,11 @@ export class ConnectionImpl implements Connection {
    */
   public readonly remotePeer: PeerId
 
-  /**
-   * Connection metadata
-   */
-  public readonly stat: ConnectionStat
+  public direction: Direction
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: keyof typeof Status
 
   /**
    * User provided tags
@@ -71,15 +76,17 @@ export class ConnectionImpl implements Connection {
    * Any libp2p transport should use an upgrader to return this connection.
    */
   constructor (init: ConnectionInit) {
-    const { remoteAddr, remotePeer, newStream, close, getStreams, stat } = init
+    const { remoteAddr, remotePeer, newStream, close, getStreams } = init
 
     this.id = `${(parseInt(String(Math.random() * 1e9))).toString(36)}${Date.now()}`
     this.remoteAddr = remoteAddr
     this.remotePeer = remotePeer
-    this.stat = {
-      ...stat,
-      status: OPEN
-    }
+    this.direction = init.direction
+    this.status = OPEN
+    this.timeline = init.timeline
+    this.multiplexer = init.multiplexer
+    this.encryption = init.encryption
+
     this._newStream = newStream
     this._close = close
     this._getStreams = getStreams
@@ -102,11 +109,11 @@ export class ConnectionImpl implements Connection {
    * Create a new stream from this connection
    */
   async newStream (protocols: string | string[], options?: AbortOptions): Promise<Stream> {
-    if (this.stat.status === CLOSING) {
+    if (this.status === CLOSING) {
       throw new CodeError('the connection is being closed', 'ERR_CONNECTION_BEING_CLOSED')
     }
 
-    if (this.stat.status === CLOSED) {
+    if (this.status === CLOSED) {
       throw new CodeError('the connection is closed', 'ERR_CONNECTION_CLOSED')
     }
 
@@ -116,7 +123,7 @@ export class ConnectionImpl implements Connection {
 
     const stream = await this._newStream(protocols, options)
 
-    stream.stat.direction = 'outbound'
+    stream.direction = 'outbound'
 
     return stream
   }
@@ -125,7 +132,7 @@ export class ConnectionImpl implements Connection {
    * Add a stream when it is opened to the registry
    */
   addStream (stream: Stream): void {
-    stream.stat.direction = 'inbound'
+    stream.direction = 'inbound'
   }
 
   /**
@@ -139,11 +146,11 @@ export class ConnectionImpl implements Connection {
    * Close the connection
    */
   async close (): Promise<void> {
-    if (this.stat.status === CLOSED || this._closing) {
+    if (this.status === CLOSED || this._closing) {
       return
     }
 
-    this.stat.status = CLOSING
+    this.status = CLOSING
 
     // close all streams - this can throw if we're not multiplexed
     try {
@@ -157,8 +164,8 @@ export class ConnectionImpl implements Connection {
     await this._close()
     this._closing = false
 
-    this.stat.timeline.close = Date.now()
-    this.stat.status = CLOSED
+    this.timeline.close = Date.now()
+    this.status = CLOSED
   }
 }
 

package/src/connection-manager/connection-pruner.ts

@@ -106,8 +106,8 @@ export class ConnectionPruner {
       }
 
       // if the peers have an equal tag value then we want to close short-lived connections first
-      const connectionALifespan = a.stat.timeline.open
-      const connectionBLifespan = b.stat.timeline.open
+      const connectionALifespan = a.timeline.open
+      const connectionBLifespan = b.timeline.open
 
       if (connectionALifespan < connectionBLifespan) {
         return 1

package/src/connection-manager/index.ts

@@ -273,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++
@@ -294,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
             }
@@ -316,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
             }

package/src/identify/identify.ts

@@ -23,7 +23,7 @@ import {
   MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } from './consts.js'
 import { Identify } from './pb/message.js'
-import type { IdentifyServiceComponents, IdentifyServiceInit } from './index.js'
+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'
@@ -49,10 +49,11 @@ const defaultValues = {
   maxPushIncomingStreams: 1,
   maxPushOutgoingStreams: 1,
   maxObservedAddresses: 10,
-  maxIdentifyMessageSize: 8192
+  maxIdentifyMessageSize: 8192,
+  runOnConnectionOpen: true
 }
 
-export class DefaultIdentifyService implements Startable {
+export class DefaultIdentifyService implements Startable, IdentifyService {
   private readonly identifyProtocolStr: string
   private readonly identifyPushProtocolStr: string
   public readonly host: {
@@ -100,11 +101,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) => {
@@ -296,7 +299,7 @@ export class DefaultIdentifyService implements Startable {
     }
   }
 
-  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,
@@ -344,6 +347,8 @@ export class DefaultIdentifyService implements Startable {
     }
 
     this.events.safeDispatchEvent('peer:identify', { detail: result })
+
+    return result
   }
 
   /**

package/src/identify/index.ts

@@ -4,10 +4,11 @@ import {
 } from './consts.js'
 import { DefaultIdentifyService } from './identify.js'
 import { Identify } from './pb/message.js'
-import type { Libp2pEvents } from '@libp2p/interface'
+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'
@@ -39,6 +40,11 @@ export interface IdentifyServiceInit {
   maxPushIncomingStreams?: number
   maxPushOutgoingStreams?: number
   maxObservedAddresses?: number
+
+  /**
+   * Whether to automatically dial identify on newly opened connections (default: true)
+   */
+  runOnConnectionOpen?: boolean
 }
 
 export interface IdentifyServiceComponents {
@@ -60,6 +66,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/upgrader.ts

@@ -89,7 +89,7 @@ function countStreams (protocol: string, direction: 'inbound' | 'outbound', conn
   let streamCount = 0
 
   connection.streams.forEach(stream => {
-    if (stream.stat.direction === direction && stream.stat.protocol === protocol) {
+    if (stream.direction === direction && stream.protocol === protocol) {
       streamCount++
     }
   })
@@ -403,7 +403,7 @@ export class DefaultUpgrader implements Upgrader {
               // the souce/sink
               muxedStream.source = stream.source
               muxedStream.sink = stream.sink
-              muxedStream.stat.protocol = protocol
+              muxedStream.protocol = protocol
 
               // If a protocol stream has been successfully negotiated and is to be passed to the application,
               // the peerstore should ensure that the peer is registered with that protocol
@@ -419,7 +419,7 @@ export class DefaultUpgrader implements Upgrader {
             .catch(err => {
               log.error(err)
 
-              if (muxedStream.stat.timeline.close == null) {
+              if (muxedStream.timeline.close == null) {
                 muxedStream.close()
               }
             })
@@ -472,7 +472,7 @@ export class DefaultUpgrader implements Upgrader {
           // the souce/sink
           muxedStream.source = stream.source
           muxedStream.sink = stream.sink
-          muxedStream.stat.protocol = protocol
+          muxedStream.protocol = protocol
 
           this.components.metrics?.trackProtocolStream(muxedStream, connection)
 
@@ -480,7 +480,7 @@ export class DefaultUpgrader implements Upgrader {
         } catch (err: any) {
           log.error('could not create new stream', err)
 
-          if (muxedStream.stat.timeline.close == null) {
+          if (muxedStream.timeline.close == null) {
             muxedStream.close()
           }
 
@@ -508,7 +508,7 @@ export class DefaultUpgrader implements Upgrader {
           // Wait for close to finish before notifying of the closure
           (async () => {
             try {
-              if (connection.stat.status === 'OPEN') {
+              if (connection.status === 'OPEN') {
                 await connection.close()
               }
             } catch (err: any) {
@@ -536,13 +536,11 @@ export class DefaultUpgrader implements Upgrader {
     connection = createConnection({
       remoteAddr: maConn.remoteAddr,
       remotePeer,
-      stat: {
-        status: 'OPEN',
-        direction,
-        timeline: maConn.timeline,
-        multiplexer: muxer?.protocol,
-        encryption: cryptoProtocol
-      },
+      status: 'OPEN',
+      direction,
+      timeline: maConn.timeline,
+      multiplexer: muxer?.protocol,
+      encryption: cryptoProtocol,
       newStream: newStream ?? errConnectionNotMultiplexed,
       getStreams: () => { if (muxer != null) { return muxer.streams } else { return errConnectionNotMultiplexed() } },
       close: async () => {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.45.9-daeb43d8'
+export const version = '0.45.9-e9cafd3d'
 export const name = 'libp2p'