libp2p 2.3.1 → 2.4.0-5c4a79e5a

package/src/address-manager/ip-mappings.ts

@@ -0,0 +1,191 @@
+import { isIPv4 } from '@chainsafe/is-ip'
+import { multiaddr, protocols } from '@multiformats/multiaddr'
+import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { Logger } from '@libp2p/interface'
+import type { NodeAddress } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export const defaultValues = {
+  maxObservedAddresses: 10
+}
+
+interface PublicAddressMapping {
+  internalIp: string
+  internalPort: number
+  externalIp: string
+  externalPort: number
+  externalFamily: 4 | 6
+  protocol: 'tcp' | 'udp'
+  verified: boolean
+  expires: number
+  lastVerified?: number
+}
+
+const CODEC_IP4 = 0x04
+const CODEC_IP6 = 0x29
+const CODEC_TCP = 0x06
+const CODEC_UDP = 0x0111
+
+export class IPMappings {
+  private readonly log: Logger
+  private readonly mappings: Map<string, PublicAddressMapping[]>
+
+  constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
+    this.log = components.logger.forComponent('libp2p:address-manager:ip-mappings')
+    this.mappings = new Map()
+  }
+
+  has (ma: Multiaddr): boolean {
+    const tuples = ma.stringTuples()
+
+    for (const mappings of this.mappings.values()) {
+      for (const mapping of mappings) {
+        if (mapping.externalIp === tuples[0][1]) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }
+
+  add (internalIp: string, internalPort: number, externalIp: string, externalPort: number = internalPort, protocol: 'tcp' | 'udp' = 'tcp'): void {
+    const key = `${internalIp}-${internalPort}-${protocol}`
+    const mappings = this.mappings.get(key) ?? []
+    const mapping: PublicAddressMapping = {
+      internalIp,
+      internalPort,
+      externalIp,
+      externalPort,
+      externalFamily: isIPv4(externalIp) ? 4 : 6,
+      protocol,
+      verified: false,
+      expires: 0
+    }
+    mappings.push(mapping)
+
+    this.mappings.set(key, mappings)
+  }
+
+  remove (ma: Multiaddr): boolean {
+    const tuples = ma.stringTuples()
+    const host = tuples[0][1] ?? ''
+    const protocol = tuples[1][0] === CODEC_TCP ? 'tcp' : 'udp'
+    const port = parseInt(tuples[1][1] ?? '0')
+    let wasConfident = false
+
+    for (const [key, mappings] of this.mappings.entries()) {
+      for (let i = 0; i < mappings.length; i++) {
+        const mapping = mappings[i]
+
+        if (mapping.externalIp === host && mapping.externalPort === port && mapping.protocol === protocol) {
+          this.log('removing %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, host, port, protocol)
+
+          wasConfident = wasConfident || mapping.verified
+          mappings.splice(i, 1)
+          i--
+        }
+      }
+
+      if (mappings.length === 0) {
+        this.mappings.delete(key)
+      }
+    }
+
+    return wasConfident
+  }
+
+  getAll (addresses: NodeAddress[]): NodeAddress[] {
+    const ipMappedAddresses: NodeAddress[] = []
+
+    for (const { multiaddr: ma } of addresses) {
+      const tuples = ma.stringTuples()
+      let tuple: string | undefined
+
+      // see if the internal host/port/protocol tuple has been mapped externally
+      if ((tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) && tuples[1][0] === CODEC_TCP) {
+        tuple = `${tuples[0][1]}-${tuples[1][1]}-tcp`
+      } else if ((tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) && tuples[1][0] === CODEC_UDP) {
+        tuple = `${tuples[0][1]}-${tuples[1][1]}-udp`
+      }
+
+      if (tuple == null) {
+        continue
+      }
+
+      const mappings = this.mappings.get(tuple)
+
+      if (mappings == null) {
+        continue
+      }
+
+      for (const mapping of mappings) {
+        tuples[0][0] = mapping.externalFamily === 4 ? CODEC_IP4 : CODEC_IP6
+        tuples[0][1] = mapping.externalIp
+        tuples[1][1] = `${mapping.externalPort}`
+
+        ipMappedAddresses.push({
+          multiaddr: multiaddr(`/${
+            tuples.map(tuple => {
+              return [
+                protocols(tuple[0]).name,
+                tuple[1]
+              ].join('/')
+            }).join('/')
+          }`),
+          verified: mapping.verified,
+          type: 'ip-mapping',
+          expires: mapping.expires,
+          lastVerified: mapping.lastVerified
+        })
+      }
+    }
+
+    return ipMappedAddresses
+  }
+
+  confirm (ma: Multiaddr, ttl: number): boolean {
+    const tuples = ma.stringTuples()
+    const host = tuples[0][1]
+    let startingConfidence = false
+
+    for (const mappings of this.mappings.values()) {
+      for (const mapping of mappings) {
+        // eslint-disable-next-line max-depth
+        if (mapping.externalIp === host) {
+          this.log('marking %s to %s IP mapping as verified', mapping.internalIp, mapping.externalIp)
+          startingConfidence = mapping.verified
+          mapping.verified = true
+          mapping.expires = Date.now() + ttl
+          mapping.lastVerified = Date.now()
+        }
+      }
+    }
+
+    return startingConfidence
+  }
+
+  unconfirm (ma: Multiaddr, ttl: number): boolean {
+    const tuples = ma.stringTuples()
+    const host = tuples[0][1] ?? ''
+    const protocol = tuples[1][0] === CODEC_TCP ? 'tcp' : 'udp'
+    const port = parseInt(tuples[1][1] ?? '0')
+    let wasConfident = false
+
+    for (const mappings of this.mappings.values()) {
+      for (let i = 0; i < mappings.length; i++) {
+        const mapping = mappings[i]
+
+        if (mapping.externalIp === host && mapping.externalPort === port && mapping.protocol === protocol) {
+          this.log('removing verification of %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, host, port, protocol)
+
+          wasConfident = wasConfident || mapping.verified
+          mapping.verified = false
+          mapping.expires = Date.now() + ttl
+        }
+      }
+    }
+
+    return wasConfident
+  }
+}

package/src/address-manager/observed-addresses.ts

@@ -0,0 +1,94 @@
+import { isLinkLocal } from '@libp2p/utils/multiaddr/is-link-local'
+import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { multiaddr } from '@multiformats/multiaddr'
+import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { Logger } from '@libp2p/interface'
+import type { NodeAddress } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export const defaultValues = {
+  maxObservedAddresses: 10
+}
+
+interface ObservedAddressMetadata {
+  verified: boolean
+  expires: number
+  lastVerified?: number
+}
+
+export class ObservedAddresses {
+  private readonly log: Logger
+  private readonly addresses: Map<string, ObservedAddressMetadata>
+  private readonly maxObservedAddresses: number
+
+  constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
+    this.log = components.logger.forComponent('libp2p:address-manager:observed-addresses')
+    this.addresses = new Map()
+    this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
+  }
+
+  has (ma: Multiaddr): boolean {
+    return this.addresses.has(ma.toString())
+  }
+
+  removePrefixed (prefix: string): void {
+    for (const key of this.addresses.keys()) {
+      if (key.toString().startsWith(prefix)) {
+        this.addresses.delete(key)
+      }
+    }
+  }
+
+  add (ma: Multiaddr): void {
+    if (this.addresses.size === this.maxObservedAddresses) {
+      return
+    }
+
+    if (isPrivate(ma) || isLinkLocal(ma)) {
+      return
+    }
+
+    this.log('adding observed address %a', ma)
+    this.addresses.set(ma.toString(), {
+      verified: false,
+      expires: 0
+    })
+  }
+
+  getAll (): NodeAddress[] {
+    return Array.from(this.addresses)
+      .map(([ma, metadata]) => ({
+        multiaddr: multiaddr(ma),
+        verified: metadata.verified,
+        type: 'observed',
+        expires: metadata.expires,
+        lastVerified: metadata.lastVerified
+      }))
+  }
+
+  remove (ma: Multiaddr): boolean {
+    const startingConfidence = this.addresses.get(ma.toString())?.verified ?? false
+
+    this.log('removing observed address %a', ma)
+    this.addresses.delete(ma.toString())
+
+    return startingConfidence
+  }
+
+  confirm (ma: Multiaddr, ttl: number): boolean {
+    const addrString = ma.toString()
+    const metadata = this.addresses.get(addrString) ?? {
+      verified: false,
+      expires: Date.now() + ttl,
+      lastVerified: Date.now()
+    }
+    const startingConfidence = metadata.verified
+    metadata.verified = true
+    metadata.lastVerified = Date.now()
+
+    this.log('marking observed address %a as verified', addrString)
+    this.addresses.set(addrString, metadata)
+
+    return startingConfidence
+  }
+}

package/src/address-manager/transport-addresses.ts

@@ -0,0 +1,116 @@
+import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import type { AddressManagerComponents, AddressManagerInit } from './index.js'
+import type { Logger } from '@libp2p/interface'
+import type { NodeAddress } from '@libp2p/interface-internal'
+import type { Multiaddr } from '@multiformats/multiaddr'
+
+export const defaultValues = {
+  maxObservedAddresses: 10
+}
+
+interface TransportAddressMetadata {
+  verified: boolean
+  expires: number
+  lastVerified?: number
+}
+
+export class TransportAddresses {
+  private readonly log: Logger
+  private readonly addresses: Map<string, TransportAddressMetadata>
+  private readonly maxObservedAddresses: number
+
+  constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
+    this.log = components.logger.forComponent('libp2p:address-manager:observed-addresses')
+    this.addresses = new Map()
+    this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
+  }
+
+  get (multiaddr: Multiaddr, ttl: number): NodeAddress {
+    if (isPrivate(multiaddr)) {
+      return {
+        multiaddr,
+        verified: true,
+        type: 'transport',
+        expires: Date.now() + ttl,
+        lastVerified: Date.now()
+      }
+    }
+
+    const key = this.toKey(multiaddr)
+    let metadata = this.addresses.get(key)
+
+    if (metadata == null) {
+      metadata = {
+        verified: false,
+        expires: 0
+      }
+
+      this.addresses.set(key, metadata)
+    }
+
+    return {
+      multiaddr,
+      verified: metadata.verified,
+      type: 'transport',
+      expires: metadata.expires,
+      lastVerified: metadata.lastVerified
+    }
+  }
+
+  has (ma: Multiaddr): boolean {
+    const key = this.toKey(ma)
+    return this.addresses.has(key)
+  }
+
+  remove (ma: Multiaddr): boolean {
+    const key = this.toKey(ma)
+    const startingConfidence = this.addresses.get(key)?.verified ?? false
+
+    this.log('removing observed address %a', ma)
+    this.addresses.delete(key)
+
+    return startingConfidence
+  }
+
+  confirm (ma: Multiaddr, ttl: number): boolean {
+    const key = this.toKey(ma)
+    const metadata = this.addresses.get(key) ?? {
+      verified: false,
+      expires: 0,
+      lastVerified: 0
+    }
+
+    const startingConfidence = metadata.verified
+
+    metadata.verified = true
+    metadata.expires = Date.now() + ttl
+    metadata.lastVerified = Date.now()
+
+    this.addresses.set(key, metadata)
+
+    return startingConfidence
+  }
+
+  unconfirm (ma: Multiaddr, ttl: number): boolean {
+    const key = this.toKey(ma)
+    const metadata = this.addresses.get(key) ?? {
+      verified: false,
+      expires: 0
+    }
+
+    const startingConfidence = metadata.verified
+
+    metadata.verified = false
+    metadata.expires = Date.now() + ttl
+
+    this.addresses.set(key, metadata)
+
+    return startingConfidence
+  }
+
+  private toKey (ma: Multiaddr): string {
+    const options = ma.toOptions()
+
+    return `${options.host}-${options.port}-${options.transport}`
+  }
+}

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

@@ -1,19 +1,33 @@
 import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { WebSockets } from '@multiformats/multiaddr-matcher'
 import type { ConnectionGater } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+const CODEC_IP4 = 0x04
+const CODEC_IP6 = 0x29
+
 /**
- * Returns a connection gater that disallows dialling private addresses by
- * default. Browsers are severely limited in their resource usage so don't
- * waste time trying to dial undiallable addresses.
+ * Returns a connection gater that disallows dialling private addresses or
+ * insecure websockets by default.
+ *
+ * Browsers are severely limited in their resource usage so don't waste time
+ * trying to dial undiallable addresses, and they also print verbose error
+ * messages when making connections over insecure transports which causes
+ * confusion.
  */
 export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
   return {
     denyDialPeer: async () => false,
     denyDialMultiaddr: async (multiaddr: Multiaddr) => {
+      // do not connect to insecure websockets by default
+      if (WebSockets.matches(multiaddr)) {
+        return false
+      }
+
       const tuples = multiaddr.stringTuples()
 
-      if (tuples[0][0] === 4 || tuples[0][0] === 41) {
+      // do not connect to private addresses by default
+      if (tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) {
         return Boolean(isPrivateIp(`${tuples[0][1]}`))
       }
 

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

@@ -1,6 +1,8 @@
 import { PeerMap } from '@libp2p/peer-collections'
 import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
 import { MAX_CONNECTIONS } from './constants.js'
+import { multiaddrToIpNet } from './utils.js'
+import type { IpNet } from '@chainsafe/netmask'
 import type { Libp2pEvents, Logger, ComponentLogger, TypedEventTarget, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -29,13 +31,13 @@ export class ConnectionPruner {
   private readonly maxConnections: number
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
-  private readonly allow: Multiaddr[]
+  private readonly allow: IpNet[]
   private readonly events: TypedEventTarget<Libp2pEvents>
   private readonly log: Logger
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
-    this.allow = init.allow ?? defaultOptions.allow
+    this.allow = (init.allow ?? []).map(ma => multiaddrToIpNet(ma))
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
     this.events = components.events
@@ -107,8 +109,8 @@ export class ConnectionPruner {
     for (const connection of sortedConnections) {
       this.log('too many connections open - closing a connection to %p', connection.remotePeer)
       // check allow list
-      const connectionInAllowList = this.allow.some((ma) => {
-        return connection.remoteAddr.toString().startsWith(ma.toString())
+      const connectionInAllowList = this.allow.some((ipNet) => {
+        return ipNet.contains(connection.remoteAddr.nodeAddress().address)
       })
 
       // Connections in the allow list should be excluded from pruning

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

@@ -1,11 +1,11 @@
 /* eslint-disable max-depth */
 import { TimeoutError, DialError, setMaxListeners, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { PriorityQueue, type PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
-import { type Multiaddr, type Resolver, resolvers, multiaddr } from '@multiformats/multiaddr'
+import { PriorityQueue } from '@libp2p/utils/priority-queue'
+import { resolvers, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { Circuit } from '@multiformats/multiaddr-matcher'
-import { type ClearableSignal, anySignal } from 'any-signal'
+import { anySignal } from 'any-signal'
 import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { DialDeniedError, NoValidAddressesError } from '../errors.js'
@@ -23,7 +23,9 @@ import { resolveMultiaddrs } from './utils.js'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
 import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents } from '@libp2p/interface'
 import type { OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
+import type { PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
 import type { DNS } from '@multiformats/dns'
+import type { Multiaddr, Resolver } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
 
 export interface PendingDialTarget {
@@ -204,7 +206,12 @@ export class DialQueue {
       options?.onProgress?.(new CustomProgressEvent('dial-queue:start-dial'))
       // create abort conditions - need to do this before `calculateMultiaddrs` as
       // we may be about to resolve a dns addr which can time out
-      const signal = this.createDialAbortController(options?.signal)
+      const signal = anySignal([
+        this.shutDownController.signal,
+        options.signal
+      ])
+      setMaxListeners(Infinity, signal)
+
       let addrsToDial: Address[]
 
       try {
@@ -299,25 +306,11 @@ export class DialQueue {
       peerId,
       priority: options.priority ?? DEFAULT_DIAL_PRIORITY,
       multiaddrs: new Set(multiaddrs.map(ma => ma.toString())),
-      signal: options.signal,
+      signal: options.signal ?? AbortSignal.timeout(this.dialTimeout),
       onProgress: options.onProgress
     })
   }
 
-  private createDialAbortController (userSignal?: AbortSignal): ClearableSignal {
-    // let any signal abort the dial
-    const signal = anySignal([
-      AbortSignal.timeout(this.dialTimeout),
-      this.shutDownController.signal,
-      userSignal
-    ])
-
-    // This emitter gets listened to a lot
-    setMaxListeners(Infinity, signal)
-
-    return signal
-  }
-
   // eslint-disable-next-line complexity
   private async calculateMultiaddrs (peerId?: PeerId, multiaddrs: Set<string> = new Set<string>(), options: OpenConnectionOptions = {}): Promise<Address[]> {
     const addrs: Address[] = [...multiaddrs].map(ma => ({

package/src/connection-manager/index.ts

@@ -9,6 +9,8 @@ import { ConnectionPruner } from './connection-pruner.js'
 import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL } from './constants.js'
 import { DialQueue } from './dial-queue.js'
 import { ReconnectQueue } from './reconnect-queue.js'
+import { multiaddrToIpNet } from './utils.js'
+import type { IpNet } from '@chainsafe/netmask'
 import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
@@ -176,8 +178,8 @@ export interface DefaultConnectionManagerComponents {
 export class DefaultConnectionManager implements ConnectionManager, Startable {
   private started: boolean
   private readonly connections: PeerMap<Connection[]>
-  private readonly allow: Multiaddr[]
-  private readonly deny: Multiaddr[]
+  private readonly allow: IpNet[]
+  private readonly deny: IpNet[]
   private readonly maxIncomingPendingConnections: number
   private incomingPendingConnections: number
   private outboundPendingConnections: number
@@ -216,8 +218,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.onDisconnect = this.onDisconnect.bind(this)
 
     // allow/deny lists
-    this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
-    this.deny = (init.deny ?? []).map(ma => multiaddr(ma))
+    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(str))
+    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(str))
 
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
@@ -237,7 +239,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       logger: components.logger
     }, {
       maxConnections: this.maxConnections,
-      allow: this.allow
+      allow: init.allow?.map(a => multiaddr(a))
     })
 
     this.dialQueue = new DialQueue(components, {
@@ -395,6 +397,10 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.log('stopped')
   }
 
+  getMaxConnections (): number {
+    return this.maxConnections
+  }
+
   onConnect (evt: CustomEvent<Connection>): void {
     void this._onConnect(evt).catch(err => {
       this.log.error(err)
@@ -571,7 +577,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   async acceptIncomingConnection (maConn: MultiaddrConnection): Promise<boolean> {
     // check deny list
     const denyConnection = this.deny.some(ma => {
-      return maConn.remoteAddr.toString().startsWith(ma.toString())
+      return ma.contains(maConn.remoteAddr.nodeAddress().address)
     })
 
     if (denyConnection) {
@@ -580,8 +586,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     }
 
     // check allow list
-    const allowConnection = this.allow.some(ma => {
-      return maConn.remoteAddr.toString().startsWith(ma.toString())
+    const allowConnection = this.allow.some(ipNet => {
+      return ipNet.contains(maConn.remoteAddr.nodeAddress().address)
     })
 
     if (allowConnection) {

package/src/connection-manager/utils.ts

@@ -1,6 +1,7 @@
-import { resolvers } from '@multiformats/multiaddr'
+import { multiaddr, resolvers, type Multiaddr, type ResolveOptions } from '@multiformats/multiaddr'
+import { convertToIpNet } from '@multiformats/multiaddr/convert'
+import type { IpNet } from '@chainsafe/netmask'
 import type { LoggerOptions } from '@libp2p/interface'
-import type { Multiaddr, ResolveOptions } from '@multiformats/multiaddr'
 
 /**
  * Recursively resolve DNSADDR multiaddrs
@@ -28,3 +29,35 @@ export async function resolveMultiaddrs (ma: Multiaddr, options: ResolveOptions
 
   return output
 }
+
+/**
+ * Converts a multiaddr string or object to an IpNet object.
+ * If the multiaddr doesn't include /ipcidr, it will encapsulate with the appropriate CIDR:
+ * - /ipcidr/32 for IPv4
+ * - /ipcidr/128 for IPv6
+ *
+ * @param {string | Multiaddr} ma - The multiaddr string or object to convert.
+ * @returns {IpNet} The converted IpNet object.
+ * @throws {Error} Throws an error if the multiaddr is not valid.
+ */
+export function multiaddrToIpNet (ma: string | Multiaddr): IpNet {
+  try {
+    let parsedMa: Multiaddr
+    if (typeof ma === 'string') {
+      parsedMa = multiaddr(ma)
+    } else {
+      parsedMa = ma
+    }
+
+    // Check if /ipcidr is already present
+    if (!parsedMa.protoNames().includes('ipcidr')) {
+      const isIPv6 = parsedMa.protoNames().includes('ip6')
+      const cidr = isIPv6 ? '/ipcidr/128' : '/ipcidr/32'
+      parsedMa = parsedMa.encapsulate(cidr)
+    }
+
+    return convertToIpNet(parsedMa)
+  } catch (error) {
+    throw new Error(`Can't convert to IpNet, Invalid multiaddr format: ${ma}`)
+  }
+}

package/src/index.ts

@@ -18,7 +18,7 @@ import { generateKeyPair } from '@libp2p/crypto/keys'
 import { peerIdFromPrivateKey } from '@libp2p/peer-id'
 import { validateConfig } from './config.js'
 import { Libp2p as Libp2pClass } from './libp2p.js'
-import type { AddressManagerInit, AddressFilter } from './address-manager.js'
+import type { AddressManagerInit, AddressFilter } from './address-manager/index.js'
 import type { Components } from './components.js'
 import type { ConnectionManagerInit } from './connection-manager/index.js'
 import type { ConnectionMonitorInit } from './connection-monitor.js'

package/src/libp2p.ts

@@ -8,7 +8,7 @@ import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { MemoryDatastore } from 'datastore-core/memory'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { AddressManager } from './address-manager.js'
+import { AddressManager } from './address-manager/index.js'
 import { checkServiceDependencies, defaultComponents } from './components.js'
 import { connectionGater } from './config/connection-gater.js'
 import { DefaultConnectionManager } from './connection-manager/index.js'

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.3.1'
-export const name = 'libp2p'
+export const version = '2.4.0-5c4a79e5a'
+export const name = 'js-libp2p'