libp2p 2.1.3 → 2.1.4-24fa1d5af

package/src/connection/index.ts

@@ -161,13 +161,6 @@ export class ConnectionImpl implements Connection {
     }
 
     try {
-      this.log.trace('closing all streams')
-
-      // close all streams gracefully - this can throw if we're not multiplexed
-      await Promise.all(
-        this.streams.map(async s => s.close(options))
-      )
-
       this.log.trace('closing underlying transport')
 
       // close raw connection
@@ -184,18 +177,19 @@ export class ConnectionImpl implements Connection {
   }
 
   abort (err: Error): void {
+    if (this.status === 'closed') {
+      return
+    }
+
     this.log.error('aborting connection to %a due to error', this.remoteAddr, err)
 
     this.status = 'closing'
-    this.streams.forEach(s => { s.abort(err) })
-
-    this.log.error('all streams aborted', this.streams.length)
 
     // Abort raw connection
     this._abort(err)
 
-    this.timeline.close = Date.now()
     this.status = 'closed'
+    this.timeline.close = Date.now()
   }
 }
 

package/src/connection-manager/address-sorter.ts

@@ -0,0 +1,137 @@
+import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { Circuit, WebSockets, WebSocketsSecure, WebRTC, WebRTCDirect, WebTransport, TCP } from '@multiformats/multiaddr-matcher'
+import type { Address } from '@libp2p/interface'
+
+/**
+ * Sorts addresses by order of reliability, where they have presented the fewest
+ * problems:
+ *
+ * TCP -> WebSockets/Secure -> WebRTC -> WebRTCDirect -> WebTransport
+ */
+// eslint-disable-next-line complexity
+export function reliableTransportsFirst (a: Address, b: Address): -1 | 0 | 1 {
+  const isATCP = TCP.exactMatch(a.multiaddr)
+  const isBTCP = TCP.exactMatch(b.multiaddr)
+
+  if (isATCP && !isBTCP) {
+    return -1
+  }
+
+  if (!isATCP && isBTCP) {
+    return 1
+  }
+
+  const isAWebSocketSecure = WebSocketsSecure.exactMatch(a.multiaddr)
+  const isBWebSocketSecure = WebSocketsSecure.exactMatch(b.multiaddr)
+
+  if (isAWebSocketSecure && !isBWebSocketSecure) {
+    return -1
+  }
+
+  if (!isAWebSocketSecure && isBWebSocketSecure) {
+    return 1
+  }
+
+  const isAWebSocket = WebSockets.exactMatch(a.multiaddr)
+  const isBWebSocket = WebSockets.exactMatch(b.multiaddr)
+
+  if (isAWebSocket && !isBWebSocket) {
+    return -1
+  }
+
+  if (!isAWebSocket && isBWebSocket) {
+    return 1
+  }
+
+  const isAWebRTC = WebRTC.exactMatch(a.multiaddr)
+  const isBWebRTC = WebRTC.exactMatch(b.multiaddr)
+
+  if (isAWebRTC && !isBWebRTC) {
+    return -1
+  }
+
+  if (!isAWebRTC && isBWebRTC) {
+    return 1
+  }
+
+  const isAWebRTCDirect = WebRTCDirect.exactMatch(a.multiaddr)
+  const isBWebRTCDirect = WebRTCDirect.exactMatch(b.multiaddr)
+
+  if (isAWebRTCDirect && !isBWebRTCDirect) {
+    return -1
+  }
+
+  if (!isAWebRTCDirect && isBWebRTCDirect) {
+    return 1
+  }
+
+  const isAWebTransport = WebTransport.exactMatch(a.multiaddr)
+  const isBWebTransport = WebTransport.exactMatch(b.multiaddr)
+
+  if (isAWebTransport && !isBWebTransport) {
+    return -1
+  }
+
+  if (!isAWebTransport && isBWebTransport) {
+    return 1
+  }
+
+  // ... everything else
+  return 0
+}
+
+/**
+ * Compare function for array.sort() that moves public addresses to the start
+ * of the array.
+ */
+export function publicAddressesFirst (a: Address, b: Address): -1 | 0 | 1 {
+  const isAPrivate = isPrivate(a.multiaddr)
+  const isBPrivate = isPrivate(b.multiaddr)
+
+  if (isAPrivate && !isBPrivate) {
+    return 1
+  } else if (!isAPrivate && isBPrivate) {
+    return -1
+  }
+
+  return 0
+}
+
+/**
+ * Compare function for array.sort() that moves certified addresses to the start
+ * of the array.
+ */
+export function certifiedAddressesFirst (a: Address, b: Address): -1 | 0 | 1 {
+  if (a.isCertified && !b.isCertified) {
+    return -1
+  } else if (!a.isCertified && b.isCertified) {
+    return 1
+  }
+
+  return 0
+}
+
+/**
+ * Compare function for array.sort() that moves circuit relay addresses to the
+ * end of the array.
+ */
+export function circuitRelayAddressesLast (a: Address, b: Address): -1 | 0 | 1 {
+  const isACircuit = Circuit.exactMatch(a.multiaddr)
+  const isBCircuit = Circuit.exactMatch(b.multiaddr)
+
+  if (isACircuit && !isBCircuit) {
+    return 1
+  } else if (!isACircuit && isBCircuit) {
+    return -1
+  }
+
+  return 0
+}
+
+export function defaultAddressSorter (addresses: Address[]): Address[] {
+  return addresses
+    .sort(reliableTransportsFirst)
+    .sort(certifiedAddressesFirst)
+    .sort(circuitRelayAddressesLast)
+    .sort(publicAddressesFirst)
+}

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

@@ -40,21 +40,29 @@ export class ConnectionPruner {
     this.peerStore = components.peerStore
     this.events = components.events
     this.log = components.logger.forComponent('libp2p:connection-manager:connection-pruner')
+    this.maybePruneConnections = this.maybePruneConnections.bind(this)
+  }
 
-    // check the max connection limit whenever a peer connects
-    components.events.addEventListener('connection:open', () => {
-      this.maybePruneConnections()
-        .catch(err => {
-          this.log.error(err)
-        })
-    })
+  start (): void {
+    this.events.addEventListener('connection:open', this.maybePruneConnections)
+  }
+
+  stop (): void {
+    this.events.removeEventListener('connection:open', this.maybePruneConnections)
+  }
+
+  maybePruneConnections (): void {
+    this._maybePruneConnections()
+      .catch(err => {
+        this.log.error('error while pruning connections %e', err)
+      })
   }
 
   /**
    * If we have more connections than our maximum, select some excess connections
    * to prune based on peer value
    */
-  async maybePruneConnections (): Promise<void> {
+  private async _maybePruneConnections (): Promise<void> {
     const connections = this.connectionManager.getConnections()
     const numConnections = connections.length
 

package/src/connection-manager/dial-queue.ts

@@ -1,7 +1,6 @@
 /* eslint-disable max-depth */
 import { TimeoutError, DialError, setMaxListeners, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { PriorityQueue, type PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
 import { type Multiaddr, type Resolver, resolvers, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
@@ -11,6 +10,7 @@ import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DialDeniedError, NoValidAddressesError } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
+import { defaultAddressSorter } from './address-sorter.js'
 import {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
@@ -47,7 +47,6 @@ interface DialerInit {
 }
 
 const defaultOptions = {
-  addressSorter: defaultAddressSort,
   maxParallelDials: MAX_PARALLEL_DIALS,
   maxDialQueueLength: MAX_DIAL_QUEUE_LENGTH,
   maxPeerAddrsToDial: MAX_PEER_ADDRS_TO_DIAL,
@@ -71,7 +70,7 @@ interface DialQueueComponents {
 export class DialQueue {
   public queue: PriorityQueue<Connection, DialQueueJobOptions>
   private readonly components: DialQueueComponents
-  private readonly addressSorter: AddressSorter
+  private readonly addressSorter?: AddressSorter
   private readonly maxPeerAddrsToDial: number
   private readonly maxDialQueueLength: number
   private readonly dialTimeout: number
@@ -80,7 +79,7 @@ export class DialQueue {
   private readonly log: Logger
 
   constructor (components: DialQueueComponents, init: DialerInit = {}) {
-    this.addressSorter = init.addressSorter ?? defaultOptions.addressSorter
+    this.addressSorter = init.addressSorter
     this.maxPeerAddrsToDial = init.maxPeerAddrsToDial ?? defaultOptions.maxPeerAddrsToDial
     this.maxDialQueueLength = init.maxDialQueueLength ?? defaultOptions.maxDialQueueLength
     this.dialTimeout = init.dialTimeout ?? defaultOptions.dialTimeout
@@ -153,7 +152,7 @@ export class DialQueue {
       })
     })
 
-    if (existingConnection != null) {
+    if (existingConnection?.status === 'open') {
       this.log('already connected to %a', existingConnection.remoteAddr)
       options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
       return existingConnection
@@ -467,7 +466,7 @@ export class DialQueue {
       gatedAdrs.push(addr)
     }
 
-    const sortedGatedAddrs = gatedAdrs.sort(this.addressSorter)
+    const sortedGatedAddrs = this.addressSorter == null ? defaultAddressSorter(gatedAdrs) : gatedAdrs.sort(this.addressSorter)
 
     // make sure we actually have some addresses to dial
     if (sortedGatedAddrs.length === 0) {

package/src/connection-manager/index.ts

@@ -1,6 +1,5 @@
-import { InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
+import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
 import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
@@ -181,6 +180,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly deny: Multiaddr[]
   private readonly maxIncomingPendingConnections: number
   private incomingPendingConnections: number
+  private outboundPendingConnections: number
   private readonly maxConnections: number
 
   public readonly dialQueue: DialQueue
@@ -214,8 +214,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
-    this.events.addEventListener('connection:open', this.onConnect)
-    this.events.addEventListener('connection:close', this.onDisconnect)
 
     // allow/deny lists
     this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
@@ -223,6 +221,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
+    this.outboundPendingConnections = 0
 
     // controls individual peers trying to dial us too quickly
     this.inboundConnectionRateLimiter = new RateLimiter({
@@ -242,7 +241,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     })
 
     this.dialQueue = new DialQueue(components, {
-      addressSorter: init.addressSorter ?? defaultAddressSort,
+      addressSorter: init.addressSorter,
       maxParallelDials: init.maxParallelDials ?? MAX_PARALLEL_DIALS,
       maxDialQueueLength: init.maxDialQueueLength ?? MAX_DIAL_QUEUE_LENGTH,
       maxPeerAddrsToDial: init.maxPeerAddrsToDial ?? MAX_PEER_ADDRS_TO_DIAL,
@@ -268,10 +267,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
   readonly [Symbol.toStringTag] = '@libp2p/connection-manager'
 
-  isStarted (): boolean {
-    return this.started
-  }
-
   /**
    * Starts the Connection Manager. If Metrics are not enabled on libp2p
    * only event loop and connection limits will be monitored.
@@ -283,16 +278,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
         const metric = {
           inbound: 0,
           'inbound pending': this.incomingPendingConnections,
-          outbound: 0
+          outbound: 0,
+          'outbound pending': this.outboundPendingConnections
         }
 
         for (const conns of this.connections.values()) {
           for (const conn of conns) {
-            if (conn.direction === 'inbound') {
-              metric.inbound++
-            } else {
-              metric.outbound++
-            }
+            metric[conn.direction]++
           }
         }
 
@@ -356,9 +348,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       }
     })
 
+    this.events.addEventListener('connection:open', this.onConnect)
+    this.events.addEventListener('connection:close', this.onDisconnect)
+
     await start(
       this.dialQueue,
-      this.reconnectQueue
+      this.reconnectQueue,
+      this.connectionPruner
     )
 
     this.started = true
@@ -369,9 +365,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
    * Stops the Connection Manager
    */
   async stop (): Promise<void> {
+    this.events.removeEventListener('connection:open', this.onConnect)
+    this.events.removeEventListener('connection:close', this.onDisconnect)
+
     await stop(
       this.reconnectQueue,
-      this.dialQueue
+      this.dialQueue,
+      this.connectionPruner
     )
 
     // Close all connections we're tracking
@@ -413,17 +413,19 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return
     }
 
-    const peerId = connection.remotePeer
-    const storedConns = this.connections.get(peerId)
-    let isNewPeer = false
-
-    if (storedConns != null) {
-      storedConns.push(connection)
-    } else {
-      isNewPeer = true
-      this.connections.set(peerId, [connection])
+    if (connection.status !== 'open') {
+      // this can happen when the remote closes the connection immediately after
+      // opening
+      return
     }
 
+    const peerId = connection.remotePeer
+    const isNewPeer = !this.connections.has(peerId)
+    const storedConns = this.connections.get(peerId) ?? []
+    storedConns.push(connection)
+
+    this.connections.set(peerId, storedConns)
+
     // only need to store RSA public keys, all other types are embedded in the peer id
     if (peerId.publicKey != null && peerId.type === 'RSA') {
       await this.peerStore.patch(peerId, {
@@ -441,20 +443,21 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
    */
   onDisconnect (evt: CustomEvent<Connection>): void {
     const { detail: connection } = evt
+    const peerId = connection.remotePeer
+    const peerConns = this.connections.get(peerId) ?? []
 
-    if (!this.started) {
-      // This can happen when we are in the process of shutting down the node
-      return
-    }
+    // remove closed connection
+    const filteredPeerConns = peerConns.filter(conn => conn.id !== connection.id)
 
-    const peerId = connection.remotePeer
-    let storedConn = this.connections.get(peerId)
+    // update peer connections
+    this.connections.set(peerId, filteredPeerConns)
 
-    if (storedConn != null && storedConn.length > 1) {
-      storedConn = storedConn.filter((conn) => conn.id !== connection.id)
-      this.connections.set(peerId, storedConn)
-    } else if (storedConn != null) {
+    if (filteredPeerConns.length === 0) {
+      // trigger disconnect event if no connections remain
+      this.log('onDisconnect remove all connections for peer %p', peerId)
       this.connections.delete(peerId)
+
+      // broadcast disconnect event
       this.events.safeDispatchEvent('peer:disconnect', { detail: connection.remotePeer })
     }
   }
@@ -478,73 +481,77 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   }
 
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
-    if (!this.isStarted()) {
+    if (!this.started) {
       throw new NotStartedError('Not started')
     }
 
-    options.signal?.throwIfAborted()
+    this.outboundPendingConnections++
 
-    const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+    try {
+      options.signal?.throwIfAborted()
 
-    if (this.peerId.equals(peerId)) {
-      throw new InvalidPeerIdError('Can not dial self')
-    }
+      const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+
+      if (this.peerId.equals(peerId)) {
+        throw new InvalidPeerIdError('Can not dial self')
+      }
 
-    if (peerId != null && options.force !== true) {
-      this.log('dial %p', peerId)
-      const existingConnection = this.getConnections(peerId)
-        .find(conn => conn.limits == null)
+      if (peerId != null && options.force !== true) {
+        this.log('dial %p', peerId)
+        const existingConnection = this.getConnections(peerId)
+          .find(conn => conn.limits == null)
 
-      if (existingConnection != null) {
-        this.log('had an existing non-limited connection to %p', peerId)
+        if (existingConnection != null) {
+          this.log('had an existing non-limited connection to %p', peerId)
 
-        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
-        return existingConnection
+          options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+          return existingConnection
+        }
       }
-    }
 
-    const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
-      ...options,
-      priority: options.priority ?? DEFAULT_DIAL_PRIORITY
-    })
+      const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
+        ...options,
+        priority: options.priority ?? DEFAULT_DIAL_PRIORITY
+      })
 
-    if (connection.remotePeer.equals(this.peerId)) {
-      const err = new InvalidPeerIdError('Can not dial self')
-      connection.abort(err)
-      throw err
-    }
+      if (connection.status !== 'open') {
+        throw new ConnectionClosedError('Remote closed connection during opening')
+      }
 
-    let peerConnections = this.connections.get(connection.remotePeer)
+      let peerConnections = this.connections.get(connection.remotePeer)
 
-    if (peerConnections == null) {
-      peerConnections = []
-      this.connections.set(connection.remotePeer, peerConnections)
-    }
+      if (peerConnections == null) {
+        peerConnections = []
+        this.connections.set(connection.remotePeer, peerConnections)
+      }
 
-    // we get notified of connections via the Upgrader emitting "connection"
-    // events, double check we aren't already tracking this connection before
-    // storing it
-    let trackedConnection = false
+      // we get notified of connections via the Upgrader emitting "connection"
+      // events, double check we aren't already tracking this connection before
+      // storing it
+      let trackedConnection = false
 
-    for (const conn of peerConnections) {
-      if (conn.id === connection.id) {
-        trackedConnection = true
-      }
+      for (const conn of peerConnections) {
+        if (conn.id === connection.id) {
+          trackedConnection = true
+        }
 
-      // make sure we don't already have a connection to this multiaddr
-      if (options.force !== true && conn.id !== connection.id && conn.remoteAddr.equals(connection.remoteAddr)) {
-        connection.abort(new InvalidMultiaddrError('Duplicate multiaddr connection'))
+        // make sure we don't already have a connection to this multiaddr
+        if (options.force !== true && conn.id !== connection.id && conn.remoteAddr.equals(connection.remoteAddr)) {
+          connection.abort(new InvalidMultiaddrError('Duplicate multiaddr connection'))
 
-        // return the existing connection
-        return conn
+          // return the existing connection
+          return conn
+        }
       }
-    }
 
-    if (!trackedConnection) {
-      peerConnections.push(connection)
-    }
+      if (!trackedConnection) {
+        peerConnections.push(connection)
+      }
 
-    return connection
+      return connection
+    } finally {
+      this.outboundPendingConnections--
+    }
   }
 
   async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {

package/src/upgrader.ts

@@ -1,4 +1,4 @@
-import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners } from '@libp2p/interface'
+import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners, InvalidPeerIdError } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { anySignal } from 'any-signal'
@@ -304,6 +304,14 @@ export class DefaultUpgrader implements Upgrader {
         remotePeer = remotePeerId
       }
 
+      // this can happen if we dial a multiaddr without a peer id, we only find
+      // out the identity of the remote after the connection is encrypted
+      if (remotePeer.equals(this.components.peerId)) {
+        const err = new InvalidPeerIdError('Can not dial self')
+        maConn.abort(err)
+        throw err
+      }
+
       upgradedConn = encryptedConn
       if (opts?.muxerFactory != null) {
         muxerFactory = opts.muxerFactory
@@ -326,6 +334,8 @@ export class DefaultUpgrader implements Upgrader {
     } catch (err: any) {
       maConn.log.error('failed to upgrade inbound connection %s %a - %e', direction === 'inbound' ? 'from' : 'to', maConn.remoteAddr, err)
       throw err
+    } finally {
+      signal.clear()
     }
 
     await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundUpgradedConnection' : 'denyOutboundUpgradedConnection', remotePeer, maConn)
@@ -538,7 +548,7 @@ export class DefaultUpgrader implements Upgrader {
     const _timeline = maConn.timeline
     maConn.timeline = new Proxy(_timeline, {
       set: (...args) => {
-        if (connection != null && args[1] === 'close' && args[2] != null && _timeline.close == null) {
+        if (args[1] === 'close' && args[2] != null && _timeline.close == null) {
           // Wait for close to finish before notifying of the closure
           (async () => {
             try {
@@ -546,14 +556,14 @@ export class DefaultUpgrader implements Upgrader {
                 await connection.close()
               }
             } catch (err: any) {
-              connection.log.error('error closing connection after timeline close', err)
+              connection.log.error('error closing connection after timeline close %e', err)
             } finally {
               this.events.safeDispatchEvent('connection:close', {
                 detail: connection
               })
             }
           })().catch(err => {
-            connection.log.error('error thrown while dispatching connection:close event', err)
+            connection.log.error('error thrown while dispatching connection:close event %e', err)
           })
         }
 
@@ -578,25 +588,21 @@ export class DefaultUpgrader implements Upgrader {
       limits,
       logger: this.components.logger,
       newStream: newStream ?? errConnectionNotMultiplexed,
-      getStreams: () => { if (muxer != null) { return muxer.streams } else { return [] } },
+      getStreams: () => {
+        return muxer?.streams ?? []
+      },
       close: async (options?: AbortOptions) => {
-        // Ensure remaining streams are closed gracefully
-        if (muxer != null) {
-          connection.log.trace('close muxer')
-          await muxer.close(options)
-        }
+        // ensure remaining streams are closed gracefully
+        await muxer?.close(options)
 
-        connection.log.trace('close maconn')
         // close the underlying transport
         await maConn.close(options)
-        connection.log.trace('closed maconn')
       },
       abort: (err) => {
         maConn.abort(err)
-        // Ensure remaining streams are aborted
-        if (muxer != null) {
-          muxer.abort(err)
-        }
+
+        // ensure remaining streams are aborted
+        muxer?.abort(err)
       }
     })
 
@@ -604,6 +610,9 @@ export class DefaultUpgrader implements Upgrader {
       detail: connection
     })
 
+    // @ts-expect-error nah
+    connection.__maConnTimeline = _timeline
+
     return connection
   }
 

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.1.3'
+export const version = '2.1.4-24fa1d5af'
 export const name = 'libp2p'