libp2p 0.45.9-d853d124 → 0.45.9-e9cafd3d

package/src/circuit-relay/server/index.ts

@@ -1,5 +1,5 @@
 import { setMaxListeners } from 'events'
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
@@ -19,14 +19,14 @@ import { AdvertService, type AdvertServiceComponents, type AdvertServiceInit } f
 import { ReservationStore, type ReservationStoreInit } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { 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'
 import type { PeerMap } from '@libp2p/peer-collections'
 
 const log = logger('libp2p:circuit-relay:server')
@@ -193,7 +193,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
   }
 
   async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
-    log('received circuit v2 hop protocol stream from %s', connection.remotePeer)
+    log('received circuit v2 hop protocol stream from %p', connection.remotePeer)
 
     const hopTimeoutPromise = pDefer<HopMessage>()
     const timeout = setTimeout(() => {
@@ -239,7 +239,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       case HopMessage.Type.RESERVE: await this.handleReserve({ stream, request, connection }); break
       case HopMessage.Type.CONNECT: await this.handleConnect({ stream, request, connection }); break
       default: {
-        log.error('invalid hop request type %s via peer %s', request.type, connection.remotePeer)
+        log.error('invalid hop request type %s via peer %p', request.type, connection.remotePeer)
         stream.pb(HopMessage).write({ type: HopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
       }
     }
@@ -247,7 +247,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
 
   async handleReserve ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
     const hopstr = stream.pb(HopMessage)
-    log('hop reserve request from %s', connection.remotePeer)
+    log('hop reserve request from %p', connection.remotePeer)
 
     if (isRelayAddr(connection.remoteAddr)) {
       log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
@@ -329,7 +329,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       return
     }
 
-    log('hop connect request from %s', connection.remotePeer)
+    log('hop connect request from %p', connection.remotePeer)
 
     let dstPeer: PeerId
 
@@ -381,7 +381,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     })
 
     if (destinationStream == null) {
-      log.error('failed to open stream to destination peer %s', destinationConnection?.remotePeer)
+      log.error('failed to open stream to destination peer %p', destinationConnection?.remotePeer)
       hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
       return
     }
@@ -414,17 +414,17 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     try {
       response = await stopstr.read()
     } catch (err) {
-      log.error('error parsing stop message response from %s', connection.remotePeer)
+      log.error('error parsing stop message response from %p', connection.remotePeer)
     }
 
     if (response == null) {
-      log.error('could not read response from %s', connection.remotePeer)
+      log.error('could not read response from %p', connection.remotePeer)
       stream.close()
       return
     }
 
     if (response.status === Status.OK) {
-      log('stop request to %s was successful', connection.remotePeer)
+      log('stop request to %p was successful', connection.remotePeer)
       return pbstr.unwrap()
     }
 

package/src/circuit-relay/server/reservation-store.ts

@@ -2,9 +2,9 @@ import { PeerMap } from '@libp2p/peer-collections'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL, DEFAULT_MAX_RESERVATION_STORE_SIZE, DEFAULT_MAX_RESERVATION_TTL } from '../constants.js'
 import { type Limit, Status } from '../pb/index.js'
 import type { RelayReservation } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { RecursivePartial } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { RecursivePartial } from '@libp2p/interface'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED

package/src/circuit-relay/server/reservation-voucher.ts

@@ -1,6 +1,6 @@
 import { ReservationVoucher } from '../pb/index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Record } from '@libp2p/interface-record'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Record } from '@libp2p/interface/record'
 
 export interface ReservationVoucherOptions {
   relay: PeerId

package/src/circuit-relay/transport/discovery.ts

@@ -1,18 +1,17 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
-import { createTopology } from '@libp2p/topology'
 import {
   RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
 import { namespaceToCid } from '../utils.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-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 { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:circuit-relay:discover-relays')
 
@@ -57,11 +56,11 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
   async start (): Promise<void> {
     // register a topology listener for when new peers are encountered
     // that support the hop protocol
-    this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, createTopology({
+    this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
       onConnect: (peerId) => {
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
-    }))
+    })
 
     void this.discover()
       .catch(err => {

package/src/circuit-relay/transport/index.ts

@@ -1,5 +1,5 @@
-import { symbol, type Upgrader, type Listener, type Transport, type CreateListenerOptions } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { symbol, type Transport, type CreateListenerOptions, type Listener, type Upgrader } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
 import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
@@ -13,17 +13,16 @@ import { StopMessage, HopMessage, Status } from '../pb/index.js'
 import { RelayDiscovery, type RelayDiscoveryComponents } from './discovery.js'
 import { createListener } from './listener.js'
 import { type RelayStoreInit, ReservationStore } from './reservation-store.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-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 { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+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 { 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'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport')
@@ -267,7 +266,7 @@ class CircuitRelayTransport implements Transport {
         localAddr: relayAddr.encapsulate(`/p2p-circuit/p2p/${this.peerId.toString()}`)
       })
 
-      log('new outbound connection %s', maConn.remoteAddr)
+      log('new outbound connection %a', maConn.remoteAddr)
       return await this.upgrader.upgradeOutbound(maConn)
     } catch (err) {
       log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
@@ -313,17 +312,17 @@ class CircuitRelayTransport implements Transport {
     }
 
     const stopstr = pbstr.pb(StopMessage)
-    log('new circuit relay v2 stop stream from %s', connection.remotePeer)
+    log('new circuit relay v2 stop stream from %p', connection.remotePeer)
 
     // Validate the STOP request has the required input
     if (request.type !== StopMessage.Type.CONNECT) {
-      log.error('invalid stop connect request via peer %s', connection.remotePeer)
+      log.error('invalid stop connect request via peer %p', connection.remotePeer)
       stopstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
       return
     }
 
     if (!isValidStop(request)) {
-      log.error('invalid stop connect request via peer %s', connection.remotePeer)
+      log.error('invalid stop connect request via peer %p', connection.remotePeer)
       stopstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
       return
     }
@@ -347,7 +346,7 @@ class CircuitRelayTransport implements Transport {
 
     log('new inbound connection %s', maConn.remoteAddr)
     await this.upgrader.upgradeInbound(maConn)
-    log('%s connection %s upgraded', 'inbound', maConn.remoteAddr)
+    log('%s connection %a upgraded', 'inbound', maConn.remoteAddr)
   }
 }
 

package/src/circuit-relay/transport/listener.ts

@@ -1,14 +1,14 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { CodeError } from '@libp2p/interface/errors'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import type { ReservationStore } from './reservation-store.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Listener, ListenerEvents } from '@libp2p/interface/transport'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
@@ -37,7 +37,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
   }
 
   async listen (addr: Multiaddr): Promise<void> {
-    log('listen on %s', addr)
+    log('listen on %a', addr)
 
     const relayPeerStr = addr.getPeerId()
     let relayConn: Connection | undefined

package/src/circuit-relay/transport/reservation-store.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { multiaddr } from '@multiformats/multiaddr'
@@ -8,13 +8,13 @@ import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { Reservation } from '../pb/index.js'
-import type { Connection } from '@libp2p/interface-connection'
-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 { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { 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:circuit-relay:transport:reservation-store')
 
@@ -237,7 +237,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   }
 
   async #createReservation (connection: Connection): Promise<Reservation> {
-    log('requesting reservation from %s', connection.remotePeer)
+    log('requesting reservation from %p', connection.remotePeer)
     const stream = await connection.newStream(RELAY_V2_HOP_CODEC)
     const pbstr = pbStream(stream)
     const hopstr = pbstr.pb(HopMessage)

package/src/circuit-relay/utils.ts

@@ -5,7 +5,7 @@ import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
 import type { Limit } from './pb/index.js'
-import type { Stream } from '@libp2p/interface-connection'
+import type { Stream } from '@libp2p/interface/connection'
 import type { Source } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/components.ts

@@ -1,18 +1,19 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { isStartable, type Startable } from '@libp2p/interfaces/startable'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { ConnectionProtector } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Registrar } from '@libp2p/interface-registrar'
-import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import { CodeError } from '@libp2p/interface/errors'
+import { isStartable, type Startable } from '@libp2p/interface/startable'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { ConnectionProtector } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerRouting } from '@libp2p/interface/peer-routing'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Upgrader } from '@libp2p/interface/transport'
+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'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Datastore } from 'interface-datastore'
 
 export interface Components extends Record<string, any>, Startable {

package/src/config/connection-gater.browser.ts

@@ -1,5 +1,5 @@
 import isPrivate from 'private-ip'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**

package/src/config/connection-gater.ts

@@ -1,4 +1,4 @@
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 
 /**
  * Returns a default connection gater implementation that allows everything

package/src/config.ts

@@ -1,12 +1,11 @@
-import { FaultTolerance } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { FaultTolerance } from '@libp2p/interface/transport'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import mergeOptions from 'merge-options'
 import { codes, messages } from './errors.js'
 import type { Libp2pInit } from './index.js'
-import type { ServiceMap } from '@libp2p/interface-libp2p'
-import type { RecursivePartial } from '@libp2p/interfaces'
+import type { ServiceMap, RecursivePartial } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const DefaultConfig: Partial<Libp2pInit> = {

package/src/connection/index.ts

@@ -1,10 +1,10 @@
-import { symbol } from '@libp2p/interface-connection'
-import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
-import { CodeError } from '@libp2p/interfaces/errors'
+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 { Connection, ConnectionStat, Stream } from '@libp2p/interface-connection'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { AbortOptions } from '@libp2p/interface'
+import type * as Status from '@libp2p/interface/connection/status'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection')
@@ -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/auto-dial.ts

@@ -2,11 +2,11 @@ import { logger } from '@libp2p/logger'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { PeerJobQueue } from '../utils/peer-job-queue.js'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 
 const log = logger('libp2p:connection-manager:auto-dial')
 

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

@@ -1,10 +1,10 @@
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { MAX_CONNECTIONS } from './constants.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
@@ -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/dial-queue.ts

@@ -1,5 +1,5 @@
 import { setMaxListeners } from 'events'
-import { AbortError, CodeError } from '@libp2p/interfaces/errors'
+import { AbortError, CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
@@ -16,14 +16,13 @@ import {
   MAX_PEER_ADDRS_TO_DIAL
 } from './constants.js'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { AddressSorter } from '@libp2p/interface-libp2p'
-import type { Metric, Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Address, PeerStore } from '@libp2p/interface-peer-store'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { AddressSorter, AbortOptions } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { Metric, Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Address, PeerStore } from '@libp2p/interface/peer-store'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -419,13 +418,13 @@ export class DialQueue {
         // let any signal abort the dial
         const signal = combineSignals(controller.signal, options.signal)
         signal.addEventListener('abort', () => {
-          log('dial to %s aborted', addr)
+          log('dial to %a aborted', addr)
         })
         const deferred = pDefer<Connection>()
 
         await peerDialQueue.add(async () => {
           if (signal.aborted) {
-            log('dial to %s was aborted before reaching the head of the peer dial queue', addr)
+            log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
             deferred.reject(new AbortError())
             return
           }
@@ -434,7 +433,7 @@ export class DialQueue {
           await this.queue.add(async () => {
             try {
               if (signal.aborted) {
-                log('dial to %s was aborted before reaching the head of the dial queue', addr)
+                log('dial to %a was aborted before reaching the head of the dial queue', addr)
                 deferred.reject(new AbortError())
                 return
               }
@@ -469,13 +468,13 @@ export class DialQueue {
                 }
               })
 
-              log('dial to %s succeeded', addr)
+              log('dial to %a succeeded', addr)
 
               // resolve the connection promise
               deferred.resolve(conn)
             } catch (err: any) {
               // something only went wrong if our signal was not aborted
-              log.error('error during dial of %s', addr, err)
+              log.error('error during dial of %a', addr, err)
               deferred.reject(err)
             }
           }, {