libp2p 0.45.9 → 0.46.0

package/src/insecure/index.ts

@@ -22,15 +22,15 @@
  * ```
  */
 
-import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface-connection-encrypter/errors'
+import { UnexpectedPeerError, InvalidCryptoExchangeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes, peerIdFromKeys } from '@libp2p/peer-id'
 import { handshake } from 'it-handshake'
 import * as lp from 'it-length-prefixed'
 import map from 'it-map'
 import { Exchange, KeyType } from './pb/proto.js'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface/connection-encrypter'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Duplex, Source } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/libp2p.ts

@@ -1,10 +1,10 @@
 import { setMaxListeners } from 'events'
 import { unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { type ContentRouting, contentRouting } from '@libp2p/interface-content-routing'
-import { peerDiscovery } from '@libp2p/interface-peer-discovery'
-import { type PeerRouting, peerRouting } from '@libp2p/interface-peer-routing'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { EventEmitter, CustomEvent } from '@libp2p/interfaces/events'
+import { type ContentRouting, contentRouting } from '@libp2p/interface/content-routing'
+import { CodeError } from '@libp2p/interface/errors'
+import { EventEmitter, CustomEvent } from '@libp2p/interface/events'
+import { peerDiscovery } from '@libp2p/interface/peer-discovery'
+import { type PeerRouting, peerRouting } from '@libp2p/interface/peer-routing'
 import { DefaultKeyChain } from '@libp2p/keychain'
 import { logger } from '@libp2p/logger'
 import { PeerSet } from '@libp2p/peer-collections'
@@ -29,15 +29,15 @@ import { DefaultTransportManager } from './transport-manager.js'
 import { DefaultUpgrader } from './upgrader.js'
 import type { Components } from './components.js'
 import type { Libp2p, Libp2pInit, Libp2pOptions } from './index.js'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { KeyChain } from '@libp2p/interface-keychain'
-import type { Libp2pEvents, PendingDial, ServiceMap } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { Libp2pEvents, PendingDial, ServiceMap, AbortOptions } from '@libp2p/interface'
+import type { Connection, NewStreamOptions, Stream } from '@libp2p/interface/connection'
+import type { KeyChain } from '@libp2p/interface/keychain'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Topology } from '@libp2p/interface/topology'
+import type { StreamHandler, StreamHandlerOptions } from '@libp2p/interface-internal/registrar'
 import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p')
@@ -99,7 +99,13 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     components.events.addEventListener('peer:update', evt => {
       // if there was no peer previously in the peer store this is a new peer
       if (evt.detail.previous == null) {
-        this.safeDispatchEvent('peer:discovery', { detail: evt.detail.peer })
+        const peerInfo: PeerInfo = {
+          id: evt.detail.peer.id,
+          multiaddrs: evt.detail.peer.addresses.map(a => a.multiaddr),
+          protocols: evt.detail.peer.protocols
+        }
+
+        this.safeDispatchEvent('peer:discovery', { detail: peerInfo })
       }
     })
 
@@ -283,7 +289,7 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     return this.components.connectionManager.openConnection(peer, options)
   }
 
-  async dialProtocol (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options: AbortOptions = {}): Promise<Stream> {
+  async dialProtocol (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options: NewStreamOptions = {}): Promise<Stream> {
     if (protocols == null) {
       throw new CodeError('no protocols were provided to open a stream', codes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
     }
@@ -307,12 +313,12 @@ export class Libp2pNode<T extends ServiceMap = Record<string, unknown>> extends
     return this.components.registrar.getProtocols()
   }
 
-  async hangUp (peer: PeerId | Multiaddr): Promise<void> {
+  async hangUp (peer: PeerId | Multiaddr, options: AbortOptions = {}): Promise<void> {
     if (isMultiaddr(peer)) {
       peer = peerIdFromString(peer.getPeerId() ?? '')
     }
 
-    await this.components.connectionManager.closeConnections(peer)
+    await this.components.connectionManager.closeConnections(peer, options)
   }
 
   /**

package/src/peer-routing.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import filter from 'it-filter'
 import first from 'it-first'
@@ -10,11 +10,11 @@ import {
   requirePeers
 } from './content-routing/utils.js'
 import { codes, messages } from './errors.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { AbortOptions } from '@libp2p/interface'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerRouting } from '@libp2p/interface/peer-routing'
+import type { PeerStore } from '@libp2p/interface/peer-store'
 
 const log = logger('libp2p:peer-routing')
 

package/src/ping/constants.ts

@@ -1,4 +1,3 @@
-
 export const PROTOCOL = '/ipfs/ping/1.0.0'
 export const PING_LENGTH = 32
 export const PROTOCOL_VERSION = '1.0.0'

package/src/ping/index.ts

@@ -1,20 +1,18 @@
-import { setMaxListeners } from 'events'
 import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { abortableDuplex } from 'abortable-iterator'
-import { anySignal } from 'any-signal'
 import first from 'it-first'
 import { pipe } from 'it-pipe'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { codes } from '../errors.js'
 import { PROTOCOL_PREFIX, PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION, TIMEOUT, MAX_INBOUND_STREAMS, MAX_OUTBOUND_STREAMS } from './constants.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'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:ping')
@@ -27,6 +25,7 @@ export interface PingServiceInit {
   protocolPrefix?: string
   maxInboundStreams?: number
   maxOutboundStreams?: number
+  runOnTransientConnection?: boolean
 
   /**
    * How long we should wait for a ping response
@@ -46,6 +45,7 @@ class DefaultPingService implements Startable, PingService {
   private readonly timeout: number
   private readonly maxInboundStreams: number
   private readonly maxOutboundStreams: number
+  private readonly runOnTransientConnection: boolean
 
   constructor (components: PingServiceComponents, init: PingServiceInit) {
     this.components = components
@@ -54,12 +54,14 @@ class DefaultPingService implements Startable, PingService {
     this.timeout = init.timeout ?? TIMEOUT
     this.maxInboundStreams = init.maxInboundStreams ?? MAX_INBOUND_STREAMS
     this.maxOutboundStreams = init.maxOutboundStreams ?? MAX_OUTBOUND_STREAMS
+    this.runOnTransientConnection = init.runOnTransientConnection ?? true
   }
 
   async start (): Promise<void> {
     await this.components.registrar.handle(this.protocol, this.handleMessage, {
       maxInboundStreams: this.maxInboundStreams,
-      maxOutboundStreams: this.maxOutboundStreams
+      maxOutboundStreams: this.maxOutboundStreams,
+      runOnTransientConnection: this.runOnTransientConnection
     })
     this.started = true
   }
@@ -77,11 +79,19 @@ class DefaultPingService implements Startable, PingService {
    * A handler to register with Libp2p to process ping messages
    */
   handleMessage (data: IncomingStreamData): void {
+    log('incoming ping from %p', data.connection.remotePeer)
+
     const { stream } = data
+    const start = Date.now()
 
     void pipe(stream, stream)
       .catch(err => {
-        log.error(err)
+        log.error('incoming ping from %p failed with error', data.connection.remotePeer, err)
+      })
+      .finally(() => {
+        const ms = Date.now() - start
+
+        log('incoming ping from %p complete in %dms', data.connection.remotePeer, ms)
       })
   }
 
@@ -92,45 +102,53 @@ class DefaultPingService implements Startable, PingService {
    * @returns {Promise<number>}
    */
   async ping (peer: PeerId | Multiaddr | Multiaddr[], options: AbortOptions = {}): Promise<number> {
-    log('dialing %s to %p', this.protocol, peer)
+    log('pinging %p', peer)
 
     const start = Date.now()
     const data = randomBytes(PING_LENGTH)
     const connection = await this.components.connectionManager.openConnection(peer, options)
     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.protocol], {
-        signal
+      stream = await connection.newStream(this.protocol, {
+        ...options,
+        runOnTransientConnection: this.runOnTransientConnection
       })
 
       // make stream abortable
-      const source = abortableDuplex(stream, signal)
+      const source = abortableDuplex(stream, options.signal)
 
       const result = await pipe(
         [data],
         source,
         async (source) => first(source)
       )
-      const end = Date.now()
 
-      if (result == null || !uint8ArrayEquals(data, result.subarray())) {
-        throw new CodeError('Received wrong ping ack', codes.ERR_WRONG_PING_ACK)
+      const ms = Date.now() - start
+
+      if (result == null) {
+        throw new CodeError(`Did not receive a ping ack after ${ms}ms`, codes.ERR_WRONG_PING_ACK)
+      }
+
+      if (!uint8ArrayEquals(data, result.subarray())) {
+        throw new CodeError(`Received wrong ping ack after ${ms}ms`, codes.ERR_WRONG_PING_ACK)
       }
 
-      return end - start
+      log('ping %p complete in %dms', connection.remotePeer, ms)
+
+      return ms
+    } catch (err: any) {
+      log.error('error while pinging %p', connection.remotePeer, err)
+
+      stream?.abort(err)
+
+      throw err
     } finally {
       if (stream != null) {
-        stream.close()
+        await stream.close()
       }
-      signal.clear()
     }
   }
 }

package/src/pnet/index.ts

@@ -23,7 +23,7 @@
  */
 
 import { randomBytes } from '@libp2p/crypto'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { handshake } from 'it-handshake'
 import map from 'it-map'
@@ -37,7 +37,7 @@ import {
 } from './crypto.js'
 import * as Errors from './errors.js'
 import { NONCE_LENGTH } from './key-generator.js'
-import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface-connection'
+import type { ConnectionProtector, MultiaddrConnection } from '@libp2p/interface/connection'
 
 const log = logger('libp2p:pnet')
 

package/src/registrar.ts

@@ -1,13 +1,14 @@
-import { isTopology, type StreamHandlerOptions, type StreamHandlerRecord, type Registrar, type StreamHandler, type Topology } from '@libp2p/interface-registrar'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import merge from 'merge-options'
 import { codes } from './errors.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents, PeerUpdate } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, PeerUpdate } 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 { Topology } from '@libp2p/interface/topology'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { StreamHandlerOptions, StreamHandlerRecord, Registrar, StreamHandler } from '@libp2p/interface-internal/registrar'
 
 const log = logger('libp2p:registrar')
 
@@ -116,9 +117,8 @@ export class DefaultRegistrar implements Registrar {
    * Register handlers for a set of multicodecs given
    */
   async register (protocol: string, topology: Topology): Promise<string> {
-    if (!isTopology(topology)) {
-      log.error('topology must be an instance of interfaces/topology')
-      throw new CodeError('topology must be an instance of interfaces/topology', codes.ERR_INVALID_PARAMETERS)
+    if (topology == null) {
+      throw new CodeError('invalid topology', codes.ERR_INVALID_PARAMETERS)
     }
 
     // Create topology
@@ -133,9 +133,6 @@ export class DefaultRegistrar implements Registrar {
 
     topologies.set(id, topology)
 
-    // Set registrar
-    await topology.setRegistrar(this)
-
     return id
   }
 
@@ -171,7 +168,7 @@ export class DefaultRegistrar implements Registrar {
           }
 
           for (const topology of topologies.values()) {
-            topology.onDisconnect(remotePeer)
+            topology.onDisconnect?.(remotePeer)
           }
         }
       })
@@ -211,7 +208,7 @@ export class DefaultRegistrar implements Registrar {
           }
 
           for (const topology of topologies.values()) {
-            topology.onConnect(remotePeer, connection)
+            topology.onConnect?.(remotePeer, connection)
           }
         }
       })
@@ -242,7 +239,7 @@ export class DefaultRegistrar implements Registrar {
       }
 
       for (const topology of topologies.values()) {
-        topology.onDisconnect(peer.id)
+        topology.onDisconnect?.(peer.id)
       }
     }
 
@@ -260,7 +257,7 @@ export class DefaultRegistrar implements Registrar {
         if (connection == null) {
           continue
         }
-        topology.onConnect(peer.id, connection)
+        topology.onConnect?.(peer.id, connection)
       }
     }
   }

package/src/transport-manager.ts

@@ -1,16 +1,16 @@
-import { FaultTolerance } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { trackedMap } from '@libp2p/interface/metrics/tracked-map'
+import { FaultTolerance } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
-import { trackedMap } from '@libp2p/tracked-map'
 import { codes } from './errors.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection } from '@libp2p/interface-connection'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { Listener, Transport, TransportManager, Upgrader } 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 { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { Startable } from '@libp2p/interface/startable'
+import type { Listener, Transport, Upgrader } from '@libp2p/interface/transport'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:transports')
@@ -177,6 +177,10 @@ export class DefaultTransportManager implements TransportManager, Startable {
    * Starts listeners for each listen Multiaddr
    */
   async listen (addrs: Multiaddr[]): Promise<void> {
+    if (!this.isStarted()) {
+      throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
+    }
+
     if (addrs == null || addrs.length === 0) {
       log('no addresses were provided for listening, this node is dial only')
       return
@@ -190,7 +194,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
 
       // For each supported multiaddr, create a listener
       for (const addr of supportedAddrs) {
-        log('creating listener for %s on %s', key, addr)
+        log('creating listener for %s on %a', key, addr)
         const listener = transport.createListener({
           upgrader: this.components.upgrader
         })

package/src/upgrader.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 * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
@@ -9,19 +9,18 @@ import { createConnection } from './connection/index.js'
 import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { codes } from './errors.js'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
-import type { MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions } from '@libp2p/interface-connection'
-import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface-connection-encrypter'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-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 { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
-import type { Upgrader, UpgraderOptions } from '@libp2p/interface-transport'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions } from '@libp2p/interface/connection'
+import type { ConnectionEncrypter, SecuredConnection } from '@libp2p/interface/connection-encrypter'
+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 { PeerStore } from '@libp2p/interface/peer-store'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
+import type { Upgrader, UpgraderOptions } from '@libp2p/interface/transport'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
 import type { Duplex, Source } from 'it-stream-types'
 
 const log = logger('libp2p:upgrader')
@@ -33,6 +32,7 @@ interface CreateConnectionOptions {
   upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
   remotePeer: PeerId
   muxerFactory?: StreamMuxerFactory
+  transient?: boolean
 }
 
 interface OnStreamOptions {
@@ -90,7 +90,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++
     }
   })
@@ -252,7 +252,8 @@ export class DefaultUpgrader implements Upgrader {
         maConn,
         upgradedConn,
         muxerFactory,
-        remotePeer
+        remotePeer,
+        transient: opts?.transient
       })
     } finally {
       this.components.connectionManager.afterUpgradeInbound()
@@ -349,7 +350,8 @@ export class DefaultUpgrader implements Upgrader {
       maConn,
       upgradedConn,
       muxerFactory,
-      remotePeer
+      remotePeer,
+      transient: opts?.transient
     })
   }
 
@@ -363,7 +365,8 @@ export class DefaultUpgrader implements Upgrader {
       maConn,
       upgradedConn,
       remotePeer,
-      muxerFactory
+      muxerFactory,
+      transient
     } = opts
 
     let muxer: StreamMuxer | undefined
@@ -404,7 +407,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
@@ -417,11 +420,11 @@ export class DefaultUpgrader implements Upgrader {
 
               this._onStream({ connection, stream: muxedStream, protocol })
             })
-            .catch(err => {
+            .catch(async err => {
               log.error(err)
 
-              if (muxedStream.stat.timeline.close == null) {
-                muxedStream.close()
+              if (muxedStream.timeline.close == null) {
+                await muxedStream.close()
               }
             })
         },
@@ -473,7 +476,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)
 
@@ -481,8 +484,8 @@ export class DefaultUpgrader implements Upgrader {
         } catch (err: any) {
           log.error('could not create new stream', err)
 
-          if (muxedStream.stat.timeline.close == null) {
-            muxedStream.close()
+          if (muxedStream.timeline.close == null) {
+            muxedStream.abort(err)
           }
 
           if (err.code != null) {
@@ -509,7 +512,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) {
@@ -537,20 +540,26 @@ 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,
+      transient,
       newStream: newStream ?? errConnectionNotMultiplexed,
-      getStreams: () => { if (muxer != null) { return muxer.streams } else { return errConnectionNotMultiplexed() } },
-      close: async () => {
-        await maConn.close()
-        // Ensure remaining streams are closed
+      getStreams: () => { if (muxer != null) { return muxer.streams } else { return [] } },
+      close: async (options?: AbortOptions) => {
+        await maConn.close(options)
+        // Ensure remaining streams are closed gracefully
         if (muxer != null) {
-          muxer.close()
+          await muxer.close(options)
+        }
+      },
+      abort: (err) => {
+        maConn.abort(err)
+        // Ensure remaining streams are aborted
+        if (muxer != null) {
+          muxer.abort(err)
         }
       }
     })
@@ -567,7 +576,11 @@ export class DefaultUpgrader implements Upgrader {
    */
   _onStream (opts: OnStreamOptions): void {
     const { connection, stream, protocol } = opts
-    const { handler } = this.components.registrar.getHandler(protocol)
+    const { handler, options } = this.components.registrar.getHandler(protocol)
+
+    if (connection.transient && options.runOnTransientConnection !== true) {
+      throw new CodeError('Cannot open protocol stream on transient connection', 'ERR_TRANSIENT_CONNECTION')
+    }
 
     handler({ connection, stream })
   }

package/src/upnp-nat/index.ts

@@ -1,5 +1,5 @@
 import { upnpNat, type NatAPI } from '@achingbrain/nat-port-mapper'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
 import { fromNodeAddress } from '@multiformats/multiaddr'
@@ -7,10 +7,10 @@ import isPrivateIp from 'private-ip'
 import { isBrowser } from 'wherearewe'
 import { codes } from '../errors.js'
 import * as pkg from '../version.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:upnp-nat')
 const DEFAULT_TTL = 7200

package/src/utils/peer-job-queue.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import PQueue from 'p-queue'
 import { codes } from '../errors.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { QueueAddOptions, Options, Queue } from 'p-queue'
 
 // Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound

package/src/version.ts

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