@libp2p/tcp 9.1.5 → 9.1.6-2bbaf4361

package/src/index.ts

@@ -27,17 +27,10 @@
  * ```
  */
 
-import net from 'net'
-import { AbortError, CodeError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
-import * as mafmt from '@multiformats/mafmt'
-import { CustomProgressEvent } from 'progress-events'
-import { CODE_CIRCUIT, CODE_P2P, CODE_UNIX } from './constants.js'
-import { type CloseServerOnMaxConnectionsOpts, TCPListener } from './listener.js'
-import { toMultiaddrConnection } from './socket-to-conn.js'
-import { multiaddrToNetConfig } from './utils.js'
-import type { ComponentLogger, Logger, Connection, CounterGroup, Metrics, CreateListenerOptions, DialTransportOptions, Transport, Listener, OutboundConnectionUpgradeEvents } from '@libp2p/interface'
-import type { AbortOptions, Multiaddr } from '@multiformats/multiaddr'
-import type { Socket, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'
+import { TCP } from './tcp.js'
+import type { CloseServerOnMaxConnectionsOpts } from './listener.js'
+import type { ComponentLogger, CounterGroup, Metrics, CreateListenerOptions, DialTransportOptions, Transport, OutboundConnectionUpgradeEvents } from '@libp2p/interface'
+import type { AbortOptions } from '@multiformats/multiaddr'
 import type { ProgressEvent } from 'progress-events'
 
 export interface TCPOptions {
@@ -128,196 +121,7 @@ export interface TCPComponents {
 }
 
 export interface TCPMetrics {
-  dialerEvents: CounterGroup
-}
-
-class TCP implements Transport<TCPDialEvents> {
-  private readonly opts: TCPOptions
-  private readonly metrics?: TCPMetrics
-  private readonly components: TCPComponents
-  private readonly log: Logger
-
-  constructor (components: TCPComponents, options: TCPOptions = {}) {
-    this.log = components.logger.forComponent('libp2p:tcp')
-    this.opts = options
-    this.components = components
-
-    if (components.metrics != null) {
-      this.metrics = {
-        dialerEvents: components.metrics.registerCounterGroup('libp2p_tcp_dialer_events_total', {
-          label: 'event',
-          help: 'Total count of TCP dialer events by type'
-        })
-      }
-    }
-  }
-
-  readonly [transportSymbol] = true
-
-  readonly [Symbol.toStringTag] = '@libp2p/tcp'
-
-  readonly [serviceCapabilities]: string[] = [
-    '@libp2p/transport'
-  ]
-
-  async dial (ma: Multiaddr, options: TCPDialOptions): Promise<Connection> {
-    options.keepAlive = options.keepAlive ?? true
-    options.noDelay = options.noDelay ?? true
-
-    // options.signal destroys the socket before 'connect' event
-    const socket = await this._connect(ma, options)
-
-    // Avoid uncaught errors caused by unstable connections
-    socket.on('error', err => {
-      this.log('socket error', err)
-    })
-
-    const maConn = toMultiaddrConnection(socket, {
-      remoteAddr: ma,
-      socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
-      socketCloseTimeout: this.opts.socketCloseTimeout,
-      metrics: this.metrics?.dialerEvents,
-      logger: this.components.logger
-    })
-
-    const onAbort = (): void => {
-      maConn.close().catch(err => {
-        this.log.error('Error closing maConn after abort', err)
-      })
-    }
-    options.signal?.addEventListener('abort', onAbort, { once: true })
-
-    this.log('new outbound connection %s', maConn.remoteAddr)
-    const conn = await options.upgrader.upgradeOutbound(maConn)
-    this.log('outbound connection %s upgraded', maConn.remoteAddr)
-
-    options.signal?.removeEventListener('abort', onAbort)
-
-    if (options.signal?.aborted === true) {
-      conn.close().catch(err => {
-        this.log.error('Error closing conn after abort', err)
-      })
-
-      throw new AbortError()
-    }
-
-    return conn
-  }
-
-  async _connect (ma: Multiaddr, options: TCPDialOptions): Promise<Socket> {
-    options.signal?.throwIfAborted()
-    options.onProgress?.(new CustomProgressEvent('tcp:open-connection'))
-
-    return new Promise<Socket>((resolve, reject) => {
-      const start = Date.now()
-      const cOpts = multiaddrToNetConfig(ma, {
-        ...(this.opts.dialOpts ?? {}),
-        ...options
-      }) as (IpcSocketConnectOpts & TcpSocketConnectOpts)
-
-      this.log('dialing %a', ma)
-      const rawSocket = net.connect(cOpts)
-
-      const onError = (err: Error): void => {
-        const cOptsStr = cOpts.path ?? `${cOpts.host ?? ''}:${cOpts.port}`
-        err.message = `connection error ${cOptsStr}: ${err.message}`
-        this.metrics?.dialerEvents.increment({ error: true })
-
-        done(err)
-      }
-
-      const onTimeout = (): void => {
-        this.log('connection timeout %a', ma)
-        this.metrics?.dialerEvents.increment({ timeout: true })
-
-        const err = new CodeError(`connection timeout after ${Date.now() - start}ms`, 'ERR_CONNECT_TIMEOUT')
-        // Note: this will result in onError() being called
-        rawSocket.emit('error', err)
-      }
-
-      const onConnect = (): void => {
-        this.log('connection opened %a', ma)
-        this.metrics?.dialerEvents.increment({ connect: true })
-        done()
-      }
-
-      const onAbort = (): void => {
-        this.log('connection aborted %a', ma)
-        this.metrics?.dialerEvents.increment({ abort: true })
-        rawSocket.destroy()
-        done(new AbortError())
-      }
-
-      const done = (err?: Error): void => {
-        rawSocket.removeListener('error', onError)
-        rawSocket.removeListener('timeout', onTimeout)
-        rawSocket.removeListener('connect', onConnect)
-
-        if (options.signal != null) {
-          options.signal.removeEventListener('abort', onAbort)
-        }
-
-        if (err != null) {
-          reject(err); return
-        }
-
-        resolve(rawSocket)
-      }
-
-      rawSocket.on('error', onError)
-      rawSocket.on('timeout', onTimeout)
-      rawSocket.on('connect', onConnect)
-
-      if (options.signal != null) {
-        options.signal.addEventListener('abort', onAbort)
-      }
-    })
-  }
-
-  /**
-   * Creates a TCP listener. The provided `handler` function will be called
-   * anytime a new incoming Connection has been successfully upgraded via
-   * `upgrader.upgradeInbound`.
-   */
-  createListener (options: TCPCreateListenerOptions): Listener {
-    return new TCPListener({
-      ...(this.opts.listenOpts ?? {}),
-      ...options,
-      maxConnections: this.opts.maxConnections,
-      backlog: this.opts.backlog,
-      closeServerOnMaxConnections: this.opts.closeServerOnMaxConnections,
-      socketInactivityTimeout: this.opts.inboundSocketInactivityTimeout,
-      socketCloseTimeout: this.opts.socketCloseTimeout,
-      metrics: this.components.metrics,
-      logger: this.components.logger
-    })
-  }
-
-  /**
-   * Takes a list of `Multiaddr`s and returns only valid TCP addresses
-   */
-  listenFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    return multiaddrs.filter(ma => {
-      if (ma.protoCodes().includes(CODE_CIRCUIT)) {
-        return false
-      }
-
-      if (ma.protoCodes().includes(CODE_UNIX)) {
-        return true
-      }
-
-      return mafmt.TCP.matches(ma.decapsulateCode(CODE_P2P))
-    })
-  }
-
-  /**
-   * Filter check for all Multiaddrs that this transport can dial
-   */
-  dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
-    return this.listenFilter(multiaddrs)
-  }
+  dialerEvents: CounterGroup<'error' | 'timeout' | 'connect' | 'abort'>
 }
 
 export function tcp (init: TCPOptions = {}): (components: TCPComponents) => Transport {

package/src/listener.ts

@@ -1,5 +1,5 @@
 import net from 'net'
-import { CodeError, TypedEventEmitter } from '@libp2p/interface'
+import { AbortError, AlreadyStartedError, InvalidParametersError, NotStartedError, TypedEventEmitter } from '@libp2p/interface'
 import { CODE_P2P } from './constants.js'
 import { toMultiaddrConnection } from './socket-to-conn.js'
 import {
@@ -107,7 +107,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     if (context.closeServerOnMaxConnections != null) {
       // Sanity check options
       if (context.closeServerOnMaxConnections.closeAbove < context.closeServerOnMaxConnections.listenBelow) {
-        throw new CodeError('closeAbove must be >= listenBelow', 'ERR_CONNECTION_LIMITS')
+        throw new InvalidParametersError('closeAbove must be >= listenBelow')
       }
     }
 
@@ -179,7 +179,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
 
   private onSocket (socket: net.Socket): void {
     if (this.status.code !== TCPListenerStatusCode.ACTIVE) {
-      throw new CodeError('Server is not listening yet', 'ERR_SERVER_NOT_RUNNING')
+      throw new NotStartedError('Server is not listening yet')
     }
     // Avoid uncaught errors caused by unstable connections
     socket.on('error', err => {
@@ -304,7 +304,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
 
   async listen (ma: Multiaddr): Promise<void> {
     if (this.status.code === TCPListenerStatusCode.ACTIVE || this.status.code === TCPListenerStatusCode.PAUSED) {
-      throw new CodeError('server is already listening', 'ERR_SERVER_ALREADY_LISTENING')
+      throw new AlreadyStartedError('server is already listening')
     }
 
     const peerId = ma.getPeerId()
@@ -327,7 +327,7 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
   }
 
   async close (): Promise<void> {
-    const err = new CodeError('Listener is closing', 'ERR_LISTENER_CLOSING')
+    const err = new AbortError('Listener is closing')
 
     // synchronously close each connection
     this.connections.forEach(conn => {
@@ -372,9 +372,9 @@ export class TCPListener extends TypedEventEmitter<ListenerEvents> implements Li
     this.log('closing server on %s', this.server.address())
 
     // NodeJS implementation tracks listening status with `this._handle` property.
-    // - Server.close() sets this._handle to null immediately. If this._handle is null, ERR_SERVER_NOT_RUNNING is thrown
+    // - Server.close() sets this._handle to null immediately. If this._handle is null, NotStartedError is thrown
     // - Server.listening returns `this._handle !== null` https://github.com/nodejs/node/blob/386d761943bb1b217fba27d6b80b658c23009e60/lib/net.js#L1675
-    // - Server.listen() if `this._handle !== null` throws ERR_SERVER_ALREADY_LISTEN
+    // - Server.listen() if `this._handle !== null` throws AlreadyStartedError
     //
     // NOTE: Both listen and close are technically not async actions, so it's not necessary to track
     // states 'pending-close' or 'pending-listen'

package/src/socket-to-conn.ts

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface'
+import { AbortError, InvalidParametersError, TimeoutError } from '@libp2p/interface'
 import { ipPortToMultiaddr as toMultiaddr } from '@libp2p/utils/ip-port-to-multiaddr'
 import { duplex } from 'stream-to-it'
 import { CLOSE_TIMEOUT, SOCKET_TIMEOUT } from './constants.js'
@@ -47,7 +47,7 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
     if (socket.remoteAddress == null || socket.remotePort == null) {
       // this can be undefined if the socket is destroyed (for example, if the client disconnected)
       // https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketremoteaddress
-      throw new CodeError('Could not determine remote address or port', 'ERR_NO_REMOTE_ADDRESS')
+      throw new InvalidParametersError('Could not determine remote address or port')
     }
 
     remoteAddr = toMultiaddr(socket.remoteAddress, socket.remotePort)
@@ -66,7 +66,7 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
     // only destroy with an error if the remote has not sent the FIN message
     let err: Error | undefined
     if (socket.readable) {
-      err = new CodeError('Socket read timeout', 'ERR_SOCKET_READ_TIMEOUT')
+      err = new TimeoutError('Socket read timeout')
     }
 
     // if the socket times out due to inactivity we must manually close the connection
@@ -147,7 +147,7 @@ export const toMultiaddrConnection = (socket: Socket, options: ToConnectionOptio
       }
 
       const abortSignalListener = (): void => {
-        socket.destroy(new CodeError('Destroying socket after timeout', 'ERR_CLOSE_TIMEOUT'))
+        socket.destroy(new AbortError('Destroying socket after timeout'))
       }
 
       options.signal?.addEventListener('abort', abortSignalListener)

package/src/tcp.browser.ts

@@ -0,0 +1,68 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on the TCP networking stack.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { tcp } from '@libp2p/tcp'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const node = await createLibp2p({
+ *   transports: [
+ *     tcp()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/ip4/123.123.123.123/tcp/1234')
+ *
+ * // dial a TCP connection, timing out after 10 seconds
+ * const connection = await node.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ */
+
+import { serviceCapabilities, transportSymbol } from '@libp2p/interface'
+import type { TCPComponents, TCPDialEvents, TCPMetrics, TCPOptions } from './index.js'
+import type { Logger, Connection, Transport, Listener } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export class TCP implements Transport<TCPDialEvents> {
+  private readonly opts: TCPOptions
+  private readonly metrics?: TCPMetrics
+  private readonly components: TCPComponents
+  private readonly log: Logger
+
+  constructor () {
+    throw new Error('TCP connections are not possible in browsers')
+  }
+
+  readonly [transportSymbol] = true
+
+  readonly [Symbol.toStringTag] = '@libp2p/tcp'
+
+  readonly [serviceCapabilities]: string[] = [
+    '@libp2p/transport'
+  ]
+
+  async dial (): Promise<Connection> {
+    throw new Error('TCP connections are not possible in browsers')
+  }
+
+  createListener (): Listener {
+    throw new Error('TCP connections are not possible in browsers')
+  }
+
+  listenFilter (): Multiaddr[] {
+    return []
+  }
+
+  dialFilter (): Multiaddr[] {
+    return []
+  }
+}

package/src/tcp.ts

@@ -0,0 +1,230 @@
+/**
+ * @packageDocumentation
+ *
+ * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on the TCP networking stack.
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { createLibp2p } from 'libp2p'
+ * import { tcp } from '@libp2p/tcp'
+ * import { multiaddr } from '@multiformats/multiaddr'
+ *
+ * const node = await createLibp2p({
+ *   transports: [
+ *     tcp()
+ *   ]
+ * })
+ *
+ * const ma = multiaddr('/ip4/123.123.123.123/tcp/1234')
+ *
+ * // dial a TCP connection, timing out after 10 seconds
+ * const connection = await node.dial(ma, {
+ *   signal: AbortSignal.timeout(10_000)
+ * })
+ *
+ * // use connection...
+ * ```
+ */
+
+import net from 'net'
+import { AbortError, TimeoutError, serviceCapabilities, transportSymbol } from '@libp2p/interface'
+import * as mafmt from '@multiformats/mafmt'
+import { CustomProgressEvent } from 'progress-events'
+import { CODE_CIRCUIT, CODE_P2P, CODE_UNIX } from './constants.js'
+import { TCPListener } from './listener.js'
+import { toMultiaddrConnection } from './socket-to-conn.js'
+import { multiaddrToNetConfig } from './utils.js'
+import type { TCPComponents, TCPCreateListenerOptions, TCPDialEvents, TCPDialOptions, TCPMetrics, TCPOptions } from './index.js'
+import type { Logger, Connection, Transport, Listener } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Socket, IpcSocketConnectOpts, TcpSocketConnectOpts } from 'net'
+
+export class TCP implements Transport<TCPDialEvents> {
+  private readonly opts: TCPOptions
+  private readonly metrics?: TCPMetrics
+  private readonly components: TCPComponents
+  private readonly log: Logger
+
+  constructor (components: TCPComponents, options: TCPOptions = {}) {
+    this.log = components.logger.forComponent('libp2p:tcp')
+    this.opts = options
+    this.components = components
+
+    if (components.metrics != null) {
+      this.metrics = {
+        dialerEvents: components.metrics.registerCounterGroup('libp2p_tcp_dialer_events_total', {
+          label: 'event',
+          help: 'Total count of TCP dialer events by type'
+        })
+      }
+    }
+  }
+
+  readonly [transportSymbol] = true
+
+  readonly [Symbol.toStringTag] = '@libp2p/tcp'
+
+  readonly [serviceCapabilities]: string[] = [
+    '@libp2p/transport'
+  ]
+
+  async dial (ma: Multiaddr, options: TCPDialOptions): Promise<Connection> {
+    options.keepAlive = options.keepAlive ?? true
+    options.noDelay = options.noDelay ?? true
+
+    // options.signal destroys the socket before 'connect' event
+    const socket = await this._connect(ma, options)
+
+    // Avoid uncaught errors caused by unstable connections
+    socket.on('error', err => {
+      this.log('socket error', err)
+    })
+
+    const maConn = toMultiaddrConnection(socket, {
+      remoteAddr: ma,
+      socketInactivityTimeout: this.opts.outboundSocketInactivityTimeout,
+      socketCloseTimeout: this.opts.socketCloseTimeout,
+      metrics: this.metrics?.dialerEvents,
+      logger: this.components.logger
+    })
+
+    const onAbort = (): void => {
+      maConn.close().catch(err => {
+        this.log.error('Error closing maConn after abort', err)
+      })
+    }
+    options.signal?.addEventListener('abort', onAbort, { once: true })
+
+    this.log('new outbound connection %s', maConn.remoteAddr)
+    const conn = await options.upgrader.upgradeOutbound(maConn)
+    this.log('outbound connection %s upgraded', maConn.remoteAddr)
+
+    options.signal?.removeEventListener('abort', onAbort)
+
+    if (options.signal?.aborted === true) {
+      conn.close().catch(err => {
+        this.log.error('Error closing conn after abort', err)
+      })
+
+      throw new AbortError()
+    }
+
+    return conn
+  }
+
+  async _connect (ma: Multiaddr, options: TCPDialOptions): Promise<Socket> {
+    options.signal?.throwIfAborted()
+    options.onProgress?.(new CustomProgressEvent('tcp:open-connection'))
+
+    return new Promise<Socket>((resolve, reject) => {
+      const start = Date.now()
+      const cOpts = multiaddrToNetConfig(ma, {
+        ...(this.opts.dialOpts ?? {}),
+        ...options
+      }) as (IpcSocketConnectOpts & TcpSocketConnectOpts)
+
+      this.log('dialing %a', ma)
+      const rawSocket = net.connect(cOpts)
+
+      const onError = (err: Error): void => {
+        const cOptsStr = cOpts.path ?? `${cOpts.host ?? ''}:${cOpts.port}`
+        err.message = `connection error ${cOptsStr}: ${err.message}`
+        this.metrics?.dialerEvents.increment({ error: true })
+
+        done(err)
+      }
+
+      const onTimeout = (): void => {
+        this.log('connection timeout %a', ma)
+        this.metrics?.dialerEvents.increment({ timeout: true })
+
+        const err = new TimeoutError(`connection timeout after ${Date.now() - start}ms`)
+        // Note: this will result in onError() being called
+        rawSocket.emit('error', err)
+      }
+
+      const onConnect = (): void => {
+        this.log('connection opened %a', ma)
+        this.metrics?.dialerEvents.increment({ connect: true })
+        done()
+      }
+
+      const onAbort = (): void => {
+        this.log('connection aborted %a', ma)
+        this.metrics?.dialerEvents.increment({ abort: true })
+        rawSocket.destroy()
+        done(new AbortError())
+      }
+
+      const done = (err?: Error): void => {
+        rawSocket.removeListener('error', onError)
+        rawSocket.removeListener('timeout', onTimeout)
+        rawSocket.removeListener('connect', onConnect)
+
+        if (options.signal != null) {
+          options.signal.removeEventListener('abort', onAbort)
+        }
+
+        if (err != null) {
+          reject(err); return
+        }
+
+        resolve(rawSocket)
+      }
+
+      rawSocket.on('error', onError)
+      rawSocket.on('timeout', onTimeout)
+      rawSocket.on('connect', onConnect)
+
+      if (options.signal != null) {
+        options.signal.addEventListener('abort', onAbort)
+      }
+    })
+  }
+
+  /**
+   * Creates a TCP listener. The provided `handler` function will be called
+   * anytime a new incoming Connection has been successfully upgraded via
+   * `upgrader.upgradeInbound`.
+   */
+  createListener (options: TCPCreateListenerOptions): Listener {
+    return new TCPListener({
+      ...(this.opts.listenOpts ?? {}),
+      ...options,
+      maxConnections: this.opts.maxConnections,
+      backlog: this.opts.backlog,
+      closeServerOnMaxConnections: this.opts.closeServerOnMaxConnections,
+      socketInactivityTimeout: this.opts.inboundSocketInactivityTimeout,
+      socketCloseTimeout: this.opts.socketCloseTimeout,
+      metrics: this.components.metrics,
+      logger: this.components.logger
+    })
+  }
+
+  /**
+   * Takes a list of `Multiaddr`s and returns only valid TCP addresses
+   */
+  listenFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter(ma => {
+      if (ma.protoCodes().includes(CODE_CIRCUIT)) {
+        return false
+      }
+
+      if (ma.protoCodes().includes(CODE_UNIX)) {
+        return true
+      }
+
+      return mafmt.TCP.matches(ma.decapsulateCode(CODE_P2P))
+    })
+  }
+
+  /**
+   * Filter check for all Multiaddrs that this transport can dial
+   */
+  dialFilter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    return this.listenFilter(multiaddrs)
+  }
+}

package/dist/typedoc-urls.json

@@ -1,18 +0,0 @@
-{
-  "TCPComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPComponents.html",
-  ".:TCPComponents": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPComponents.html",
-  "TCPCreateListenerOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPCreateListenerOptions.html",
-  ".:TCPCreateListenerOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPCreateListenerOptions.html",
-  "TCPDialOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPDialOptions.html",
-  ".:TCPDialOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPDialOptions.html",
-  "TCPMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPMetrics.html",
-  ".:TCPMetrics": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPMetrics.html",
-  "TCPOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPOptions.html",
-  ".:TCPOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPOptions.html",
-  "TCPSocketOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPSocketOptions.html",
-  ".:TCPSocketOptions": "https://libp2p.github.io/js-libp2p/interfaces/_libp2p_tcp.TCPSocketOptions.html",
-  "TCPDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_tcp.TCPDialEvents.html",
-  ".:TCPDialEvents": "https://libp2p.github.io/js-libp2p/types/_libp2p_tcp.TCPDialEvents.html",
-  "tcp": "https://libp2p.github.io/js-libp2p/functions/_libp2p_tcp.tcp.html",
-  ".:tcp": "https://libp2p.github.io/js-libp2p/functions/_libp2p_tcp.tcp.html"
-}