libp2p 0.46.21 → 1.0.0

package/src/registrar.ts

@@ -1,16 +1,9 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { logger } from '@libp2p/logger'
+import { CodeError } from '@libp2p/interface'
 import merge from 'merge-options'
 import { codes } from './errors.js'
-import type { IdentifyResult, Libp2pEvents, PeerUpdate } from '@libp2p/interface'
-import type { TypedEventTarget } 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')
+import type { IdentifyResult, Libp2pEvents, Logger, PeerUpdate, TypedEventTarget, PeerId, PeerStore, Topology } from '@libp2p/interface'
+import type { ConnectionManager, StreamHandlerOptions, StreamHandlerRecord, Registrar, StreamHandler } from '@libp2p/interface-internal'
+import type { ComponentLogger } from '@libp2p/logger'
 
 export const DEFAULT_MAX_INBOUND_STREAMS = 32
 export const DEFAULT_MAX_OUTBOUND_STREAMS = 64
@@ -20,17 +13,20 @@ export interface RegistrarComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 /**
  * Responsible for notifying registered protocols of events in the network.
  */
 export class DefaultRegistrar implements Registrar {
+  private readonly log: Logger
   private readonly topologies: Map<string, Map<string, Topology>>
   private readonly handlers: Map<string, StreamHandlerRecord>
   private readonly components: RegistrarComponents
 
   constructor (components: RegistrarComponents) {
+    this.log = components.logger.forComponent('libp2p:registrar')
     this.topologies = new Map()
     this.handlers = new Map()
     this.components = components
@@ -178,7 +174,7 @@ export class DefaultRegistrar implements Registrar {
           return
         }
 
-        log.error('could not inform topologies of disconnecting peer %p', remotePeer, err)
+        this.log.error('could not inform topologies of disconnecting peer %p', remotePeer, err)
       })
   }
 

package/src/transport-manager.ts

@@ -1,20 +1,10 @@
-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 { CodeError, FaultTolerance } from '@libp2p/interface'
+import { trackedMap } from '@libp2p/utils/tracked-map'
 import { codes } from './errors.js'
-import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
-import type { Connection } from '@libp2p/interface/connection'
-import type { TypedEventTarget } 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 { Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, TypedEventTarget, Metrics, Startable, Listener, Transport, Upgrader } from '@libp2p/interface'
+import type { AddressManager, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const log = logger('libp2p:transports')
-
 export interface TransportManagerInit {
   faultTolerance?: FaultTolerance
 }
@@ -24,9 +14,11 @@ export interface DefaultTransportManagerComponents {
   addressManager: AddressManager
   upgrader: Upgrader
   events: TypedEventTarget<Libp2pEvents>
+  logger: ComponentLogger
 }
 
 export class DefaultTransportManager implements TransportManager, Startable {
+  private readonly log: Logger
   private readonly components: DefaultTransportManagerComponents
   private readonly transports: Map<string, Transport>
   private readonly listeners: Map<string, Listener[]>
@@ -34,6 +26,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
   private started: boolean
 
   constructor (components: DefaultTransportManagerComponents, init: TransportManagerInit = {}) {
+    this.log = components.logger.forComponent('libp2p:transports')
     this.components = components
     this.started = false
     this.transports = new Map<string, Transport>()
@@ -58,7 +51,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
       throw new CodeError(`There is already a transport with the tag ${tag}`, codes.ERR_DUPLICATE_TRANSPORT)
     }
 
-    log('adding transport %s', tag)
+    this.log('adding transport %s', tag)
 
     this.transports.set(tag, transport)
 
@@ -88,7 +81,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
   async stop (): Promise<void> {
     const tasks = []
     for (const [key, listeners] of this.listeners) {
-      log('closing listeners for %s', key)
+      this.log('closing listeners for %s', key)
       while (listeners.length > 0) {
         const listener = listeners.pop()
 
@@ -101,7 +94,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     }
 
     await Promise.all(tasks)
-    log('all listeners closed')
+    this.log('all listeners closed')
     for (const key of this.listeners.keys()) {
       this.listeners.set(key, [])
     }
@@ -182,7 +175,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
     }
 
     if (addrs == null || addrs.length === 0) {
-      log('no addresses were provided for listening, this node is dial only')
+      this.log('no addresses were provided for listening, this node is dial only')
       return
     }
 
@@ -194,7 +187,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 %a', key, addr)
+        this.log('creating listener for %s on %a', key, addr)
         const listener = transport.createListener({
           upgrader: this.components.upgrader
         })
@@ -253,7 +246,7 @@ export class DefaultTransportManager implements TransportManager, Startable {
       if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
         throw new CodeError(message, codes.ERR_NO_VALID_ADDRESSES)
       }
-      log(`libp2p in dial mode only: ${message}`)
+      this.log(`libp2p in dial mode only: ${message}`)
     }
   }
 
@@ -263,11 +256,11 @@ export class DefaultTransportManager implements TransportManager, Startable {
    */
   async remove (key: string): Promise<void> {
     const listeners = this.listeners.get(key) ?? []
-    log.trace('removing transport %s', key)
+    this.log.trace('removing transport %s', key)
 
     // Close any running listeners
     const tasks = []
-    log.trace('closing listeners for %s', key)
+    this.log.trace('closing listeners for %s', key)
     while (listeners.length > 0) {
       const listener = listeners.pop()
 

package/src/upgrader.ts

@@ -1,24 +1,12 @@
-import { CodeError } from '@libp2p/interface/errors'
-import { setMaxListeners } from '@libp2p/interface/events'
+import { CodeError, ERR_TIMEOUT, setMaxListeners } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
 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 { Libp2pEvents, AbortOptions, ComponentLogger, Logger } 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 { TypedEventTarget } 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'
+import type { Libp2pEvents, AbortOptions, ComponentLogger, Logger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader, UpgraderOptions } from '@libp2p/interface'
+import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
 const DEFAULT_PROTOCOL_SELECT_TIMEOUT = 30000
 
@@ -26,7 +14,7 @@ interface CreateConnectionOptions {
   cryptoProtocol: string
   direction: 'inbound' | 'outbound'
   maConn: MultiaddrConnection
-  upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
+  upgradedConn: MultiaddrConnection
   remotePeer: PeerId
   muxerFactory?: StreamMuxerFactory
   transient?: boolean
@@ -38,7 +26,7 @@ interface OnStreamOptions {
   protocol: string
 }
 
-export interface CryptoResult extends SecuredConnection {
+export interface CryptoResult extends SecuredConnection<MultiaddrConnection> {
   protocol: string
 }
 
@@ -107,8 +95,6 @@ export interface DefaultUpgraderComponents {
   logger: ComponentLogger
 }
 
-type EncryptedConn = Duplex<AsyncGenerator<Uint8Array, any, unknown>, Source<Uint8Array>, Promise<void>>
-
 type ConnectionDeniedType = keyof Pick<ConnectionGater, 'denyOutboundConnection' | 'denyInboundEncryptedConnection' | 'denyOutboundEncryptedConnection' | 'denyInboundUpgradedConnection' | 'denyOutboundUpgradedConnection'>
 
 export class DefaultUpgrader implements Upgrader {
@@ -117,12 +103,12 @@ export class DefaultUpgrader implements Upgrader {
   private readonly muxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
   private readonly events: TypedEventTarget<Libp2pEvents>
-  readonly #log: Logger
+  private readonly log: Logger
 
   constructor (components: DefaultUpgraderComponents, init: UpgraderInit) {
     this.components = components
     this.connectionEncryption = new Map()
-    this.#log = components.logger.forComponent('libp2p:upgrader')
+    this.log = components.logger.forComponent('libp2p:upgrader')
 
     init.connectionEncryption.forEach(encrypter => {
       this.connectionEncryption.set(encrypter.protocol, encrypter)
@@ -158,16 +144,16 @@ export class DefaultUpgrader implements Upgrader {
       throw new CodeError('connection denied', codes.ERR_CONNECTION_DENIED)
     }
 
-    let encryptedConn: EncryptedConn
+    let encryptedConn: MultiaddrConnection
     let remotePeer
-    let upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
+    let upgradedConn: MultiaddrConnection
     let muxerFactory: StreamMuxerFactory | undefined
     let cryptoProtocol
 
     const signal = AbortSignal.timeout(this.inboundUpgradeTimeout)
 
     const onAbort = (): void => {
-      maConn.abort(new CodeError('inbound upgrade timeout', codes.ERR_TIMEOUT))
+      maConn.abort(new CodeError('inbound upgrade timeout', ERR_TIMEOUT))
     }
 
     signal.addEventListener('abort', onAbort, { once: true })
@@ -181,7 +167,7 @@ export class DefaultUpgrader implements Upgrader {
 
       this.components.metrics?.trackMultiaddrConnection(maConn)
 
-      this.#log('starting the inbound connection upgrade')
+      this.log('starting the inbound connection upgrade')
 
       // Protect
       let protectedConn = maConn
@@ -190,7 +176,7 @@ export class DefaultUpgrader implements Upgrader {
         const protector = this.components.connectionProtector
 
         if (protector != null) {
-          this.#log('protecting the inbound connection')
+          this.log('protecting the inbound connection')
           protectedConn = await protector.protect(maConn)
         }
       }
@@ -237,13 +223,13 @@ export class DefaultUpgrader implements Upgrader {
           upgradedConn = multiplexed.stream
         }
       } catch (err: any) {
-        this.#log.error('Failed to upgrade inbound connection', err)
+        this.log.error('Failed to upgrade inbound connection', err)
         throw err
       }
 
       await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundUpgradedConnection')
 
-      this.#log('Successfully upgraded inbound connection')
+      this.log('successfully upgraded inbound connection')
 
       return this._createConnection({
         cryptoProtocol,
@@ -274,15 +260,15 @@ export class DefaultUpgrader implements Upgrader {
       await this.shouldBlockConnection(remotePeerId, maConn, 'denyOutboundConnection')
     }
 
-    let encryptedConn
+    let encryptedConn: MultiaddrConnection
     let remotePeer: PeerId
-    let upgradedConn: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>
+    let upgradedConn: MultiaddrConnection
     let cryptoProtocol
     let muxerFactory
 
     this.components.metrics?.trackMultiaddrConnection(maConn)
 
-    this.#log('Starting the outbound connection upgrade')
+    this.log('Starting the outbound connection upgrade')
 
     // If the transport natively supports encryption, skip connection
     // protector and encryption
@@ -335,14 +321,14 @@ export class DefaultUpgrader implements Upgrader {
         upgradedConn = multiplexed.stream
       }
     } catch (err: any) {
-      this.#log.error('Failed to upgrade outbound connection', err)
+      this.log.error('Failed to upgrade outbound connection', err)
       await maConn.close(err)
       throw err
     }
 
     await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundUpgradedConnection')
 
-    this.#log('Successfully upgraded outbound connection')
+    this.log('Successfully upgraded outbound connection')
 
     return this._createConnection({
       cryptoProtocol,
@@ -386,13 +372,17 @@ export class DefaultUpgrader implements Upgrader {
           void Promise.resolve()
             .then(async () => {
               const protocols = this.components.registrar.getProtocols()
-              const { stream, protocol } = await mss.handle(muxedStream, protocols)
-              this.#log('%s: incoming stream opened on %s', direction, protocol)
+              const { stream, protocol } = await mss.handle(muxedStream, protocols, {
+                log: muxedStream.log,
+                yieldBytes: false
+              })
 
               if (connection == null) {
                 return
               }
 
+              connection.log('incoming stream opened on %s', protocol)
+
               const incomingLimit = findIncomingStreamLimit(protocol, this.components.registrar)
               const streamCount = countStreams(protocol, 'inbound', connection)
 
@@ -409,6 +399,21 @@ export class DefaultUpgrader implements Upgrader {
               muxedStream.sink = stream.sink
               muxedStream.protocol = protocol
 
+              // allow closing the write end of a not-yet-negotiated stream
+              if (stream.closeWrite != null) {
+                muxedStream.closeWrite = stream.closeWrite
+              }
+
+              // allow closing the read end of a not-yet-negotiated stream
+              if (stream.closeRead != null) {
+                muxedStream.closeRead = stream.closeRead
+              }
+
+              // make sure we don't try to negotiate a stream we are closing
+              if (stream.close != null) {
+                muxedStream.close = stream.close
+              }
+
               // 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
               await this.components.peerStore.merge(remotePeer, {
@@ -420,7 +425,7 @@ export class DefaultUpgrader implements Upgrader {
               this._onStream({ connection, stream: muxedStream, protocol })
             })
             .catch(async err => {
-              this.#log.error(err)
+              this.log.error('error handling incoming stream id %s', muxedStream.id, err.message, err.code, err.stack)
 
               if (muxedStream.timeline.close == null) {
                 await muxedStream.close()
@@ -434,12 +439,13 @@ export class DefaultUpgrader implements Upgrader {
           throw new CodeError('Stream is not multiplexed', codes.ERR_MUXER_UNAVAILABLE)
         }
 
-        this.#log('%s-%s: starting new stream on %s', connection.id, direction, protocols)
+        connection.log('starting new stream for protocols %s', protocols)
         const muxedStream = await muxer.newStream()
+        connection.log.trace('started new stream %s for protocols %s', muxedStream.id, protocols)
 
         try {
           if (options.signal == null) {
-            this.#log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
+            this.log('No abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
 
             const signal = AbortSignal.timeout(DEFAULT_PROTOCOL_SELECT_TIMEOUT)
             setMaxListeners(Infinity, signal)
@@ -450,7 +456,18 @@ export class DefaultUpgrader implements Upgrader {
             }
           }
 
-          const { stream, protocol } = await mss.select(muxedStream, protocols, options)
+          muxedStream.log.trace('selecting protocol from protocols %s', protocols)
+
+          const {
+            stream,
+            protocol
+          } = await mss.select(muxedStream, protocols, {
+            ...options,
+            log: muxedStream.log,
+            yieldBytes: true
+          })
+
+          muxedStream.log('selected protocol %s', protocol)
 
           const outgoingLimit = findOutgoingStreamLimit(protocol, this.components.registrar, options)
           const streamCount = countStreams(protocol, 'outbound', connection)
@@ -474,11 +491,26 @@ export class DefaultUpgrader implements Upgrader {
           muxedStream.sink = stream.sink
           muxedStream.protocol = protocol
 
+          // allow closing the write end of a not-yet-negotiated stream
+          if (stream.closeWrite != null) {
+            muxedStream.closeWrite = stream.closeWrite
+          }
+
+          // allow closing the read end of a not-yet-negotiated stream
+          if (stream.closeRead != null) {
+            muxedStream.closeRead = stream.closeRead
+          }
+
+          // make sure we don't try to negotiate a stream we are closing
+          if (stream.close != null) {
+            muxedStream.close = stream.close
+          }
+
           this.components.metrics?.trackProtocolStream(muxedStream, connection)
 
           return muxedStream
         } catch (err: any) {
-          this.#log.error('could not create new stream for protocols %s on connection with address %a', protocols, connection.remoteAddr, err)
+          connection.log.error('could not create new stream for protocols %s', protocols, err)
 
           if (muxedStream.timeline.close == null) {
             muxedStream.abort(err)
@@ -497,7 +529,7 @@ export class DefaultUpgrader implements Upgrader {
         muxer.sink(upgradedConn.source),
         upgradedConn.sink(muxer.source)
       ]).catch(err => {
-        this.#log.error(err)
+        this.log.error(err)
       })
     }
 
@@ -512,14 +544,14 @@ export class DefaultUpgrader implements Upgrader {
                 await connection.close()
               }
             } catch (err: any) {
-              this.#log.error(err)
+              this.log.error(err)
             } finally {
               this.events.safeDispatchEvent('connection:close', {
                 detail: connection
               })
             }
           })().catch(err => {
-            this.#log.error(err)
+            this.log.error(err)
           })
         }
 
@@ -548,14 +580,14 @@ export class DefaultUpgrader implements Upgrader {
       close: async (options?: AbortOptions) => {
         // Ensure remaining streams are closed gracefully
         if (muxer != null) {
-          this.#log.trace('close muxer')
+          this.log.trace('close muxer')
           await muxer.close(options)
         }
 
-        this.#log.trace('close maconn')
+        this.log.trace('close maconn')
         // close the underlying transport
         await maConn.close(options)
-        this.#log.trace('closed maconn')
+        this.log.trace('closed maconn')
       },
       abort: (err) => {
         maConn.abort(err)
@@ -590,13 +622,13 @@ export class DefaultUpgrader implements Upgrader {
   /**
    * Attempts to encrypt the incoming `connection` with the provided `cryptos`
    */
-  async _encryptInbound (connection: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>>): Promise<CryptoResult> {
+  async _encryptInbound (connection: MultiaddrConnection): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
-    this.#log('handling inbound crypto protocol selection', protocols)
+    this.log('handling inbound crypto protocol selection', protocols)
 
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
-        writeBytes: true
+        log: connection.log
       })
       const encrypter = this.connectionEncryption.get(protocol)
 
@@ -604,7 +636,7 @@ export class DefaultUpgrader implements Upgrader {
         throw new Error(`no crypto module found for ${protocol}`)
       }
 
-      this.#log('encrypting inbound connection...')
+      this.log('encrypting inbound connection using', protocol)
 
       return {
         ...await encrypter.secureInbound(this.components.peerId, stream),
@@ -621,19 +653,26 @@ export class DefaultUpgrader implements Upgrader {
    */
   async _encryptOutbound (connection: MultiaddrConnection, remotePeerId?: PeerId): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncryption.keys())
-    this.#log('selecting outbound crypto protocol', protocols)
+    this.log('selecting outbound crypto protocol', protocols)
 
     try {
-      const { stream, protocol } = await mss.select(connection, protocols, {
-        writeBytes: true
+      connection.log.trace('selecting encrypter from %s', protocols)
+
+      const {
+        stream,
+        protocol
+      } = await mss.select(connection, protocols, {
+        log: connection.log,
+        yieldBytes: true
       })
+
       const encrypter = this.connectionEncryption.get(protocol)
 
       if (encrypter == null) {
         throw new Error(`no crypto module found for ${protocol}`)
       }
 
-      this.#log('encrypting outbound connection to %p', remotePeerId)
+      connection.log('encrypting outbound connection to %p using %p', remotePeerId)
 
       return {
         ...await encrypter.secureOutbound(this.components.peerId, stream, remotePeerId),
@@ -648,19 +687,26 @@ export class DefaultUpgrader implements Upgrader {
    * Selects one of the given muxers via multistream-select. That
    * muxer will be used for all future streams on the connection.
    */
-  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
-    this.#log('outbound selecting muxer %s', protocols)
+    this.log('outbound selecting muxer %s', protocols)
     try {
-      const { stream, protocol } = await mss.select(connection, protocols, {
-        writeBytes: true
+      connection.log.trace('selecting stream muxer from %s', protocols)
+
+      const {
+        stream,
+        protocol
+      } = await mss.select(connection, protocols, {
+        log: connection.log,
+        yieldBytes: true
       })
-      this.#log('%s selected as muxer protocol', protocol)
+
+      connection.log('selected %s as muxer protocol', protocol)
       const muxerFactory = muxers.get(protocol)
 
       return { stream, muxerFactory }
     } catch (err: any) {
-      this.#log.error('error multiplexing outbound stream', err)
+      connection.log.error('error multiplexing outbound stream', err)
       throw new CodeError(String(err), codes.ERR_MUXER_UNAVAILABLE)
     }
   }
@@ -669,18 +715,18 @@ export class DefaultUpgrader implements Upgrader {
    * Registers support for one of the given muxers via multistream-select. The
    * selected muxer will be used for all future streams on the connection.
    */
-  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: Duplex<AsyncGenerator<Uint8Array>, Source<Uint8Array>, Promise<void>>, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
-    this.#log('inbound handling muxers %s', protocols)
+    this.log('inbound handling muxers %s', protocols)
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
-        writeBytes: true
+        log: connection.log
       })
       const muxerFactory = muxers.get(protocol)
 
       return { stream, muxerFactory }
     } catch (err: any) {
-      this.#log.error('error multiplexing inbound stream', err)
+      this.log.error('error multiplexing inbound stream', err)
       throw new CodeError(String(err), codes.ERR_MUXER_UNAVAILABLE)
     }
   }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.46.21'
+export const version = '1.0.0'
 export const name = 'libp2p'

package/dist/src/autonat/constants.d.ts

@@ -1,18 +0,0 @@
-/**
- * The prefix to use in the protocol
- */
-export declare const PROTOCOL_PREFIX = "libp2p";
-/**
- * The name to use in the protocol
- */
-export declare const PROTOCOL_NAME = "autonat";
-/**
- * The version to use in the protocol
- */
-export declare const PROTOCOL_VERSION = "1.0.0";
-export declare const TIMEOUT = 30000;
-export declare const STARTUP_DELAY = 5000;
-export declare const REFRESH_INTERVAL = 60000;
-export declare const MAX_INBOUND_STREAMS = 1;
-export declare const MAX_OUTBOUND_STREAMS = 1;
-//# sourceMappingURL=constants.d.ts.map

package/dist/src/autonat/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/autonat/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,eAAe,WAAW,CAAA;AAEvC;;GAEG;AACH,eAAO,MAAM,aAAa,YAAY,CAAA;AAEtC;;GAEG;AACH,eAAO,MAAM,gBAAgB,UAAU,CAAA;AACvC,eAAO,MAAM,OAAO,QAAQ,CAAA;AAC5B,eAAO,MAAM,aAAa,OAAO,CAAA;AACjC,eAAO,MAAM,gBAAgB,QAAQ,CAAA;AACrC,eAAO,MAAM,mBAAmB,IAAI,CAAA;AACpC,eAAO,MAAM,oBAAoB,IAAI,CAAA"}

package/dist/src/autonat/constants.js

@@ -1,18 +0,0 @@
-/**
- * The prefix to use in the protocol
- */
-export const PROTOCOL_PREFIX = 'libp2p';
-/**
- * The name to use in the protocol
- */
-export const PROTOCOL_NAME = 'autonat';
-/**
- * The version to use in the protocol
- */
-export const PROTOCOL_VERSION = '1.0.0';
-export const TIMEOUT = 30000;
-export const STARTUP_DELAY = 5000;
-export const REFRESH_INTERVAL = 60000;
-export const MAX_INBOUND_STREAMS = 1;
-export const MAX_OUTBOUND_STREAMS = 1;
-//# sourceMappingURL=constants.js.map

package/dist/src/autonat/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/autonat/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,QAAQ,CAAA;AAEvC;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAA;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAA;AACvC,MAAM,CAAC,MAAM,OAAO,GAAG,KAAK,CAAA;AAC5B,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,CAAA;AACjC,MAAM,CAAC,MAAM,gBAAgB,GAAG,KAAK,CAAA;AACrC,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAA;AACpC,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAA"}