libp2p 2.3.0 → 2.3.1-06f79b646

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "2.3.0",
+  "version": "2.3.1-06f79b646",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/libp2p#readme",
@@ -85,46 +85,47 @@
     "test:webkit": "aegir test -t browser -- --browser webkit"
   },
   "dependencies": {
-    "@libp2p/crypto": "^5.0.6",
-    "@libp2p/interface": "^2.2.0",
-    "@libp2p/interface-internal": "^2.1.0",
-    "@libp2p/logger": "^5.1.3",
-    "@libp2p/multistream-select": "^6.0.8",
-    "@libp2p/peer-collections": "^6.0.11",
-    "@libp2p/peer-id": "^5.0.7",
-    "@libp2p/peer-store": "^11.0.11",
-    "@libp2p/utils": "^6.2.0",
+    "@chainsafe/is-ip": "^2.0.2",
+    "@libp2p/crypto": "5.0.7-06f79b646",
+    "@libp2p/interface": "2.2.1-06f79b646",
+    "@libp2p/interface-internal": "2.1.1-06f79b646",
+    "@libp2p/logger": "5.1.4-06f79b646",
+    "@libp2p/multistream-select": "6.0.9-06f79b646",
+    "@libp2p/peer-collections": "6.0.12-06f79b646",
+    "@libp2p/peer-id": "5.0.8-06f79b646",
+    "@libp2p/peer-store": "11.0.12-06f79b646",
+    "@libp2p/utils": "6.2.1-06f79b646",
     "@multiformats/dns": "^1.0.6",
-    "@multiformats/multiaddr": "^12.2.3",
-    "@multiformats/multiaddr-matcher": "^1.2.1",
+    "@multiformats/multiaddr": "^12.3.3",
+    "@multiformats/multiaddr-matcher": "^1.6.0",
     "any-signal": "^4.1.1",
-    "datastore-core": "^10.0.0",
-    "interface-datastore": "^8.3.0",
-    "it-byte-stream": "^1.0.12",
+    "datastore-core": "^10.0.2",
+    "interface-datastore": "^8.3.1",
+    "it-byte-stream": "^1.1.0",
     "it-merge": "^3.0.5",
-    "it-parallel": "^3.0.7",
+    "it-parallel": "^3.0.8",
     "merge-options": "^3.0.4",
-    "multiformats": "^13.1.0",
+    "multiformats": "^13.3.1",
     "p-defer": "^4.0.1",
-    "p-retry": "^6.2.0",
-    "progress-events": "^1.0.0",
+    "p-retry": "^6.2.1",
+    "progress-events": "^1.0.1",
     "race-event": "^1.3.0",
-    "race-signal": "^1.0.2",
+    "race-signal": "^1.1.0",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "aegir": "^44.0.1",
+    "aegir": "^45.0.5",
     "delay": "^6.0.0",
     "it-all": "^3.0.6",
     "it-drain": "^3.0.7",
     "it-length-prefixed": "^9.1.0",
-    "it-map": "^3.1.0",
+    "it-map": "^3.1.1",
     "it-pair": "^2.0.6",
-    "it-stream-types": "^2.0.1",
-    "it-take": "^3.0.5",
+    "it-stream-types": "^2.0.2",
+    "it-take": "^3.0.6",
     "p-event": "^6.0.1",
     "p-wait-for": "^5.0.2",
-    "sinon": "^18.0.0",
+    "sinon": "^19.0.2",
     "sinon-ts": "^2.0.0",
     "uint8arraylist": "^2.4.8"
   },

package/src/address-manager.ts

@@ -1,3 +1,4 @@
+import { isIPv4 } from '@chainsafe/is-ip'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { debounce } from '@libp2p/utils/debounce'
 import { multiaddr, protocols } from '@multiformats/multiaddr'
@@ -5,6 +6,10 @@ import type { ComponentLogger, Libp2pEvents, Logger, TypedEventTarget, PeerId, P
 import type { AddressManager as AddressManagerInterface, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+export const defaultValues = {
+  maxObservedAddresses: 10
+}
+
 export interface AddressManagerInit {
   /**
    * Pass an function in this field to override the list of addresses
@@ -13,19 +18,29 @@ export interface AddressManagerInit {
   announceFilter?: AddressFilter
 
   /**
-   * list of multiaddrs string representation to listen
+   * A list of string multiaddrs to listen on
    */
   listen?: string[]
 
   /**
-   * list of multiaddrs string representation to announce
+   * A list of string multiaddrs to use instead of those reported by transports
    */
   announce?: string[]
 
   /**
-   * list of multiaddrs string representation to never announce
+   * A list of string multiaddrs string to never announce
    */
   noAnnounce?: string[]
+
+  /**
+   * A list of string multiaddrs to add to the list of announced addresses
+   */
+  appendAnnounce?: string[]
+
+  /**
+   * Limits the number of observed addresses we will store
+   */
+  maxObservedAddresses?: number
 }
 
 export interface AddressManagerComponents {
@@ -73,6 +88,18 @@ const CODEC_IP4 = 0x04
 const CODEC_IP6 = 0x29
 const CODEC_DNS4 = 0x36
 const CODEC_DNS6 = 0x37
+const CODEC_TCP = 0x06
+const CODEC_UDP = 0x0111
+
+interface PublicAddressMapping {
+  externalIp: string
+  externalPort: number
+}
+
+interface DNSMapping {
+  domain: string
+  confident: boolean
+}
 
 export class AddressManager implements AddressManagerInterface {
   private readonly log: Logger
@@ -80,11 +107,12 @@ export class AddressManager implements AddressManagerInterface {
   // this is an array to allow for duplicates, e.g. multiples of `/ip4/0.0.0.0/tcp/0`
   private readonly listen: string[]
   private readonly announce: Set<string>
+  private readonly appendAnnounce: Set<string>
   private readonly observed: Map<string, ObservedAddressMetadata>
   private readonly announceFilter: AddressFilter
-  private readonly ipDomainMappings: Map<string, string>
-
-  private readonly where: Error
+  private readonly ipDomainMappings: Map<string, DNSMapping>
+  private readonly publicAddressMappings: Map<string, PublicAddressMapping[]>
+  private readonly maxObservedAddresses: number
 
   /**
    * Responsible for managing the peer addresses.
@@ -93,15 +121,18 @@ export class AddressManager implements AddressManagerInterface {
    * while the announce addresses will be used for the peer addresses' to other peers in the network.
    */
   constructor (components: AddressManagerComponents, init: AddressManagerInit = {}) {
-    const { listen = [], announce = [] } = init
+    const { listen = [], announce = [], appendAnnounce = [] } = init
 
     this.components = components
     this.log = components.logger.forComponent('libp2p:address-manager')
     this.listen = listen.map(ma => ma.toString())
     this.announce = new Set(announce.map(ma => ma.toString()))
+    this.appendAnnounce = new Set(appendAnnounce.map(ma => ma.toString()))
     this.observed = new Map()
     this.ipDomainMappings = new Map()
+    this.publicAddressMappings = new Map()
     this.announceFilter = init.announceFilter ?? defaultAddressFilter
+    this.maxObservedAddresses = init.maxObservedAddresses ?? defaultValues.maxObservedAddresses
 
     // this method gets called repeatedly on startup when transports start listening so
     // debounce it so we don't cause multiple self:peer:update events to be emitted
@@ -115,8 +146,6 @@ export class AddressManager implements AddressManagerInterface {
     components.events.addEventListener('transport:close', () => {
       this._updatePeerStoreAddresses()
     })
-
-    this.where = new Error('where')
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/address-manager'
@@ -124,13 +153,8 @@ export class AddressManager implements AddressManagerInterface {
   _updatePeerStoreAddresses (): void {
     // if announce addresses have been configured, ensure they make it into our peer
     // record for things like identify
-    const addrs = this.getAnnounceAddrs()
-      .concat(this.components.transportManager.getAddrs())
-      .concat(
-        [...this.observed.entries()]
-          .filter(([_, metadata]) => metadata.confident)
-          .map(([str]) => multiaddr(str))
-      ).map(ma => {
+    const addrs = this.getAddresses()
+      .map(ma => {
         // strip our peer id if it is present
         if (ma.getPeerId() === this.components.peerId.toString()) {
           return ma.decapsulate(`/p2p/${this.components.peerId.toString()}`)
@@ -142,7 +166,9 @@ export class AddressManager implements AddressManagerInterface {
     this.components.peerStore.patch(this.components.peerId, {
       multiaddrs: addrs
     })
-      .catch(err => { this.log.error('error updating addresses', err) })
+      .catch(err => {
+        this.log.error('error updating addresses', err)
+      })
   }
 
   /**
@@ -159,6 +185,13 @@ export class AddressManager implements AddressManagerInterface {
     return Array.from(this.announce).map((a) => multiaddr(a))
   }
 
+  /**
+   * Get peer announcing multiaddrs
+   */
+  getAppendAnnounceAddrs (): Multiaddr[] {
+    return Array.from(this.appendAnnounce).map((a) => multiaddr(a))
+  }
+
   /**
    * Get observed multiaddrs
    */
@@ -170,6 +203,10 @@ export class AddressManager implements AddressManagerInterface {
    * Add peer observed addresses
    */
   addObservedAddr (addr: Multiaddr): void {
+    if (this.observed.size === this.maxObservedAddresses) {
+      return
+    }
+
     addr = stripPeerId(addr, this.components.peerId)
     const addrString = addr.toString()
 
@@ -218,22 +255,70 @@ export class AddressManager implements AddressManagerInterface {
       multiaddrs = this.components.transportManager.getAddrs()
     }
 
-    // add observed addresses we are confident in
     multiaddrs = multiaddrs
       .concat(
+        // add additional announce addresses
+        ...this.getAppendAnnounceAddrs(),
+
+        // add observed addresses we are confident in
         Array.from(this.observed)
           .filter(([ma, metadata]) => metadata.confident)
           .map(([ma]) => multiaddr(ma))
       )
 
-    const mappedMultiaddrs: Multiaddr[] = []
+    // add public addresses
+    const ipMappedMultiaddrs: Multiaddr[] = []
+    multiaddrs.forEach(ma => {
+      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) {
+        return
+      }
+
+      const mappings = this.publicAddressMappings.get(tuple)
+
+      if (mappings == null) {
+        return
+      }
+
+      for (const mapping of mappings) {
+        tuples[0][0] = isIPv4(mapping.externalIp) ? CODEC_IP4 : CODEC_IP6
+        tuples[0][1] = mapping.externalIp
+        tuples[1][1] = `${mapping.externalPort}`
+
+        ipMappedMultiaddrs.push(
+          multiaddr(`/${
+            tuples.map(tuple => {
+              return [
+                protocols(tuple[0]).name,
+                tuple[1]
+              ].join('/')
+            }).join('/')
+          }`)
+        )
+      }
+    })
+    multiaddrs = multiaddrs.concat(ipMappedMultiaddrs)
 
     // add ip->domain mappings
+    const dnsMappedMultiaddrs: Multiaddr[] = []
     for (const ma of multiaddrs) {
-      const tuples = [...ma.stringTuples()]
+      const tuples = ma.stringTuples()
       let mappedIp = false
 
-      for (const [ip, domain] of this.ipDomainMappings.entries()) {
+      for (const [ip, mapping] of this.ipDomainMappings.entries()) {
+        if (!mapping.confident) {
+          continue
+        }
+
         for (let i = 0; i < tuples.length; i++) {
           if (tuples[i][1] !== ip) {
             continue
@@ -241,20 +326,20 @@ export class AddressManager implements AddressManagerInterface {
 
           if (tuples[i][0] === CODEC_IP4) {
             tuples[i][0] = CODEC_DNS4
-            tuples[i][1] = domain
+            tuples[i][1] = mapping.domain
             mappedIp = true
           }
 
           if (tuples[i][0] === CODEC_IP6) {
             tuples[i][0] = CODEC_DNS6
-            tuples[i][1] = domain
+            tuples[i][1] = mapping.domain
             mappedIp = true
           }
         }
       }
 
       if (mappedIp) {
-        mappedMultiaddrs.push(
+        dnsMappedMultiaddrs.push(
           multiaddr(`/${
             tuples.map(tuple => {
               return [
@@ -266,8 +351,7 @@ export class AddressManager implements AddressManagerInterface {
         )
       }
     }
-
-    multiaddrs = multiaddrs.concat(mappedMultiaddrs)
+    multiaddrs = multiaddrs.concat(dnsMappedMultiaddrs)
 
     // dedupe multiaddrs
     const addrSet = new Set<string>()
@@ -305,15 +389,66 @@ export class AddressManager implements AddressManagerInterface {
 
   addDNSMapping (domain: string, addresses: string[]): void {
     addresses.forEach(ip => {
-      this.ipDomainMappings.set(ip, domain)
+      this.log('add DNS mapping %s to %s', ip, domain)
+
+      // check ip/public ip mappings to see if we think we are contactable
+      const confident = [...this.publicAddressMappings.entries()].some(([key, mappings]) => {
+        return mappings.some(mapping => mapping.externalIp === ip)
+      })
+
+      this.ipDomainMappings.set(ip, {
+        domain,
+        confident
+      })
     })
+    this._updatePeerStoreAddresses()
   }
 
   removeDNSMapping (domain: string): void {
-    for (const [key, value] of this.ipDomainMappings.entries()) {
-      if (value === domain) {
+    for (const [key, mapping] of this.ipDomainMappings.entries()) {
+      if (mapping.domain === domain) {
+        this.log('remove DNS mapping for %s', domain)
         this.ipDomainMappings.delete(key)
       }
     }
+    this._updatePeerStoreAddresses()
+  }
+
+  addPublicAddressMapping (internalIp: string, internalPort: number, externalIp: string, externalPort: number = internalPort, protocol: 'tcp' | 'udp' = 'tcp'): void {
+    const key = `${internalIp}-${internalPort}-${protocol}`
+    const mappings = this.publicAddressMappings.get(key) ?? []
+    mappings.push({
+      externalIp,
+      externalPort
+    })
+
+    this.publicAddressMappings.set(key, mappings)
+
+    // update domain mappings to indicate we are now confident that any matching
+    // ip/domain combination can now be resolved externally
+    for (const [key, mapping] of this.ipDomainMappings.entries()) {
+      if (key === externalIp) {
+        mapping.confident = true
+
+        this.ipDomainMappings.set(key, mapping)
+      }
+    }
+
+    this._updatePeerStoreAddresses()
+  }
+
+  removePublicAddressMapping (internalIp: string, internalPort: number, externalIp: string, externalPort: number = internalPort, protocol: 'tcp' | 'udp' = 'tcp'): void {
+    const key = `${internalIp}-${internalPort}-${protocol}`
+    const mappings = (this.publicAddressMappings.get(key) ?? []).filter(mapping => {
+      return mapping.externalIp !== externalIp && mapping.externalPort !== externalPort
+    })
+
+    if (mappings.length === 0) {
+      this.publicAddressMappings.delete(key)
+    } else {
+      this.publicAddressMappings.set(key, mappings)
+    }
+
+    this._updatePeerStoreAddresses()
   }
 }

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/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/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.3.0'
-export const name = 'libp2p'
+export const version = '2.3.1-06f79b646'
+export const name = 'js-libp2p'

package/LICENSE

@@ -1,4 +0,0 @@
-This project is dual licensed under MIT and Apache-2.0.
-
-MIT: https://www.opensource.org/licenses/mit
-Apache-2.0: https://www.apache.org/licenses/license-2.0

package/dist/typedoc-urls.json

@@ -1,19 +0,0 @@
-{
-  "AddressFilter": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressFilter.html",
-  "AddressManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.AddressManagerInit.html",
-  "ConnectionManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionManagerInit.html",
-  "ConnectionMonitorInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.ConnectionMonitorInit.html",
-  "Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  ".:Libp2pInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.Libp2pInit.html",
-  "TransportManagerInit": "https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.TransportManagerInit.html",
-  "Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  ".:Libp2pOptions": "https://libp2p.github.io/js-libp2p/types/libp2p.index.Libp2pOptions.html",
-  "ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  ".:ServiceFactoryMap": "https://libp2p.github.io/js-libp2p/types/libp2p.index.ServiceFactoryMap.html",
-  "createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  ".:createLibp2p": "https://libp2p.github.io/js-libp2p/functions/libp2p.index.createLibp2p.html",
-  "name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "./version:name": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.name.html",
-  "version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html",
-  "./version:version": "https://libp2p.github.io/js-libp2p/variables/libp2p.version.version.html"
-}