libp2p 0.36.2 → 0.37.0

package/src/nat-manager.ts

@@ -0,0 +1,194 @@
+import { upnpNat, NatAPI } from '@achingbrain/nat-port-mapper'
+import { logger } from '@libp2p/logger'
+import { Multiaddr } from '@multiformats/multiaddr'
+import { isBrowser } from 'wherearewe'
+import isPrivateIp from 'private-ip'
+import * as pkg from './version.js'
+import errCode from 'err-code'
+import { codes } from './errors.js'
+import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:nat')
+const DEFAULT_TTL = 7200
+
+function highPort (min = 1024, max = 65535) {
+  return Math.floor(Math.random() * (max - min + 1) + min)
+}
+
+export interface PMPOptions {
+  /**
+   * Whether to enable PMP as well as UPnP
+   */
+  enabled?: boolean
+}
+
+export interface NatManagerInit {
+  /**
+   * Whether to enable the NAT manager
+   */
+  enabled: boolean
+
+  /**
+   * Pass a value to use instead of auto-detection
+   */
+  externalAddress?: string
+
+  /**
+   * Pass a value to use instead of auto-detection
+   */
+  localAddress?: string
+
+  /**
+   * A string value to use for the port mapping description on the gateway
+   */
+  description?: string
+
+  /**
+   * How long UPnP port mappings should last for in seconds (minimum 1200)
+   */
+  ttl?: number
+
+  /**
+   * Whether to automatically refresh UPnP port mappings when their TTL is reached
+   */
+  keepAlive: boolean
+
+  /**
+   * Pass a value to use instead of auto-detection
+   */
+  gateway?: string
+}
+
+export class NatManager implements Startable {
+  private readonly components: Components
+  private readonly enabled: boolean
+  private readonly externalAddress?: string
+  private readonly localAddress?: string
+  private readonly description: string
+  private readonly ttl: number
+  private readonly keepAlive: boolean
+  private readonly gateway?: string
+  private started: boolean
+  private client?: NatAPI
+
+  constructor (components: Components, init: NatManagerInit) {
+    this.components = components
+
+    this.started = false
+    this.enabled = init.enabled
+    this.externalAddress = init.externalAddress
+    this.localAddress = init.localAddress
+    this.description = init.description ?? `${pkg.name}@${pkg.version} ${this.components.getPeerId().toString()}`
+    this.ttl = init.ttl ?? DEFAULT_TTL
+    this.keepAlive = init.keepAlive ?? true
+    this.gateway = init.gateway
+
+    if (this.ttl < DEFAULT_TTL) {
+      throw errCode(new Error(`NatManager ttl should be at least ${DEFAULT_TTL} seconds`), codes.ERR_INVALID_PARAMETERS)
+    }
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * Starts the NAT manager
+   */
+  start () {
+    if (isBrowser || !this.enabled || this.started) {
+      return
+    }
+
+    this.started = true
+
+    // done async to not slow down startup
+    this._start().catch((err) => {
+      // hole punching errors are non-fatal
+      log.error(err)
+    })
+  }
+
+  async _start () {
+    const addrs = this.components.getTransportManager().getAddrs()
+
+    for (const addr of addrs) {
+      // try to open uPnP ports for each thin waist address
+      const { family, host, port, transport } = addr.toOptions()
+
+      if (!addr.isThinWaistAddress() || transport !== 'tcp') {
+        // only bare tcp addresses
+        // eslint-disable-next-line no-continue
+        continue
+      }
+
+      if (isLoopback(addr)) {
+        // eslint-disable-next-line no-continue
+        continue
+      }
+
+      if (family !== 4) {
+        // ignore ipv6
+        // eslint-disable-next-line no-continue
+        continue
+      }
+
+      const client = await this._getClient()
+      const publicIp = this.externalAddress ?? await client.externalIp()
+
+      if (isPrivateIp(publicIp)) {
+        throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`)
+      }
+
+      const publicPort = highPort()
+
+      log(`opening uPnP connection from ${publicIp}:${publicPort} to ${host}:${port}`)
+
+      await client.map({
+        publicPort,
+        localPort: port,
+        localAddress: this.localAddress,
+        protocol: transport.toUpperCase() === 'TCP' ? 'TCP' : 'UDP'
+      })
+
+      this.components.getAddressManager().addObservedAddr(Multiaddr.fromNodeAddress({
+        family: 4,
+        address: publicIp,
+        port: publicPort
+      }, transport))
+    }
+  }
+
+  async _getClient () {
+    if (this.client != null) {
+      return this.client
+    }
+
+    this.client = await upnpNat({
+      description: this.description,
+      ttl: this.ttl,
+      keepAlive: this.keepAlive,
+      gateway: this.gateway
+    })
+
+    return this.client
+  }
+
+  /**
+   * Stops the NAT manager
+   */
+  async stop () {
+    if (isBrowser || this.client == null) {
+      return
+    }
+
+    try {
+      await this.client.close()
+      this.client = undefined
+    } catch (err: any) {
+      log.error(err)
+    }
+  }
+}

package/src/peer-record-updater.ts

@@ -0,0 +1,55 @@
+import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
+import type { Components } from '@libp2p/interfaces/components'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { logger } from '@libp2p/logger'
+import { protocols } from '@multiformats/multiaddr'
+
+const log = logger('libp2p:peer-record-updater')
+
+export class PeerRecordUpdater implements Startable {
+  private readonly components: Components
+  private started: boolean
+
+  constructor (components: Components) {
+    this.components = components
+    this.started = false
+    this.update = this.update.bind(this)
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  async start () {
+    this.started = true
+    this.components.getTransportManager().addEventListener('listener:listening', this.update)
+    this.components.getTransportManager().addEventListener('listener:close', this.update)
+    this.components.getAddressManager().addEventListener('change:addresses', this.update)
+  }
+
+  async stop () {
+    this.started = false
+    this.components.getTransportManager().removeEventListener('listener:listening', this.update)
+    this.components.getTransportManager().removeEventListener('listener:close', this.update)
+    this.components.getAddressManager().removeEventListener('change:addresses', this.update)
+  }
+
+  /**
+   * Create (or update if existing) self peer record and store it in the AddressBook.
+   */
+  update () {
+    Promise.resolve()
+      .then(async () => {
+        const peerRecord = new PeerRecord({
+          peerId: this.components.getPeerId(),
+          multiaddrs: this.components.getAddressManager().getAddresses().map(ma => ma.decapsulateCode(protocols('p2p').code))
+        })
+
+        const envelope = await RecordEnvelope.seal(peerRecord, this.components.getPeerId())
+        await this.components.getPeerStore().addressBook.consumePeerRecord(envelope)
+      })
+      .catch(err => {
+        log.error('Could not update self peer record: %o', err)
+      })
+  }
+}

package/src/peer-routing.ts

@@ -0,0 +1,186 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { codes, messages } from './errors.js'
+import {
+  storeAddresses,
+  uniquePeers,
+  requirePeers
+} from './content-routing/utils.js'
+import { TimeoutController } from 'timeout-abort-controller'
+import merge from 'it-merge'
+import { pipe } from 'it-pipe'
+import first from 'it-first'
+import drain from 'it-drain'
+import filter from 'it-filter'
+import {
+  setDelayedInterval,
+  clearDelayedInterval
+// @ts-expect-error module with no types
+} from 'set-delayed-interval'
+// @ts-expect-error setMaxListeners is missing from the node 16 types
+import { setMaxListeners } from 'events'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PeerRouting } from '@libp2p/interfaces/peer-routing'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { PeerInfo } from '@libp2p/interfaces/peer-info'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:peer-routing')
+
+export interface RefreshManagerInit {
+  /**
+   * Whether to enable the Refresh manager
+   */
+  enabled?: boolean
+
+  /**
+   * Boot delay to start the Refresh Manager (in ms)
+   */
+  bootDelay?: number
+
+  /**
+   * Interval between each Refresh Manager run (in ms)
+   */
+  interval?: number
+
+  /**
+   * How long to let each refresh run (in ms)
+   */
+  timeout?: number
+}
+
+export interface PeerRoutingInit {
+  routers: PeerRouting[]
+  refreshManager?: RefreshManagerInit
+}
+
+export class DefaultPeerRouting implements PeerRouting, Startable {
+  private readonly components: Components
+  private readonly routers: PeerRouting[]
+  private readonly refreshManagerInit: RefreshManagerInit
+  private timeoutId?: ReturnType<typeof setTimeout>
+  private started: boolean
+  private abortController?: TimeoutController
+
+  constructor (components: Components, init: PeerRoutingInit) {
+    this.components = components
+    this.routers = init.routers
+    this.refreshManagerInit = init.refreshManager ?? {}
+    this.started = false
+
+    this._findClosestPeersTask = this._findClosestPeersTask.bind(this)
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * Start peer routing service.
+   */
+  async start () {
+    if (this.started || this.routers.length === 0 || this.timeoutId != null || this.refreshManagerInit.enabled === false) {
+      return
+    }
+
+    this.timeoutId = setDelayedInterval(
+      this._findClosestPeersTask, this.refreshManagerInit.interval, this.refreshManagerInit.bootDelay
+    )
+
+    this.started = true
+  }
+
+  /**
+   * Recurrent task to find closest peers and add their addresses to the Address Book.
+   */
+  async _findClosestPeersTask () {
+    if (this.abortController != null) {
+      // we are already running the query
+      return
+    }
+
+    try {
+      this.abortController = new TimeoutController(this.refreshManagerInit.timeout ?? 10e3)
+
+      // this controller may be used while dialing lots of peers so prevent MaxListenersExceededWarning
+      // appearing in the console
+      try {
+        // fails on node < 15.4
+        setMaxListeners?.(Infinity, this.abortController.signal)
+      } catch {}
+
+      // nb getClosestPeers adds the addresses to the address book
+      await drain(this.getClosestPeers(this.components.getPeerId().toBytes(), { signal: this.abortController.signal }))
+    } catch (err: any) {
+      log.error(err)
+    } finally {
+      this.abortController?.clear()
+      this.abortController = undefined
+    }
+  }
+
+  /**
+   * Stop peer routing service.
+   */
+  async stop () {
+    clearDelayedInterval(this.timeoutId)
+
+    // abort query if it is in-flight
+    this.abortController?.abort()
+
+    this.started = false
+  }
+
+  /**
+   * Iterates over all peer routers in parallel to find the given peer
+   */
+  async findPeer (id: PeerId, options?: AbortOptions): Promise<PeerInfo> {
+    if (this.routers.length === 0) {
+      throw errCode(new Error('No peer routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+    }
+
+    if (id.toString() === this.components.getPeerId().toString()) {
+      throw errCode(new Error('Should not try to find self'), codes.ERR_FIND_SELF)
+    }
+
+    const output = await pipe(
+      merge(
+        ...this.routers.map(router => (async function * () {
+          try {
+            yield await router.findPeer(id, options)
+          } catch (err) {
+            log.error(err)
+          }
+        })())
+      ),
+      (source) => filter(source, Boolean),
+      (source) => storeAddresses(source, this.components.getPeerStore()),
+      async (source) => await first(source)
+    )
+
+    if (output != null) {
+      return output
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+  }
+
+  /**
+   * Attempt to find the closest peers on the network to the given key
+   */
+  async * getClosestPeers (key: Uint8Array, options?: AbortOptions): AsyncIterable<PeerInfo> {
+    if (this.routers.length === 0) {
+      throw errCode(new Error('No peer routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
+    }
+
+    yield * pipe(
+      merge(
+        ...this.routers.map(router => router.getClosestPeers(key, options))
+      ),
+      (source) => storeAddresses(source, this.components.getPeerStore()),
+      (source) => uniquePeers(source),
+      (source) => requirePeers(source)
+    )
+  }
+}

package/src/ping/README.md

@@ -8,7 +8,7 @@ libp2p-ping JavaScript Implementation
 ## Usage
 
 ```javascript
-var Ping = require('libp2p/src/ping')
+import Ping from 'libp2p/src/ping'
 
 Ping.mount(libp2p) // Enable this peer to echo Ping requests
 

package/src/ping/constants.ts

@@ -0,0 +1,5 @@
+
+export const PROTOCOL = '/ipfs/ping/1.0.0'
+export const PING_LENGTH = 32
+export const PROTOCOL_VERSION = '1.0.0'
+export const PROTOCOL_NAME = 'ping'

package/src/ping/index.ts

@@ -0,0 +1,84 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { codes } from '../errors.js'
+import { randomBytes } from '@libp2p/crypto'
+import { pipe } from 'it-pipe'
+import first from 'it-first'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } from './constants.js'
+import type { IncomingStreamData } from '@libp2p/interfaces/registrar'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:ping')
+
+export interface PingServiceInit {
+  protocolPrefix: string
+}
+
+export class PingService implements Startable {
+  private readonly components: Components
+  private readonly protocol: string
+  private started: boolean
+
+  constructor (components: Components, init: PingServiceInit) {
+    this.components = components
+    this.started = false
+    this.protocol = `/${init.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+  }
+
+  async start () {
+    await this.components.getRegistrar().handle(this.protocol, this.handleMessage)
+    this.started = true
+  }
+
+  async stop () {
+    await this.components.getRegistrar().unhandle(this.protocol)
+    this.started = false
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * A handler to register with Libp2p to process ping messages
+   */
+  handleMessage (data: IncomingStreamData) {
+    const { stream } = data
+
+    void pipe(stream, stream)
+      .catch(err => {
+        log.error(err)
+      })
+  }
+
+  /**
+   * Ping a given peer and wait for its response, getting the operation latency.
+   *
+   * @param {PeerId|Multiaddr} peer
+   * @returns {Promise<number>}
+   */
+  async ping (peer: PeerId): Promise<number> {
+    log('dialing %s to %p', this.protocol, peer)
+
+    const connection = await this.components.getConnectionManager().openConnection(peer)
+    const { stream } = await connection.newStream([this.protocol])
+    const start = Date.now()
+    const data = randomBytes(PING_LENGTH)
+
+    const result = await pipe(
+      [data],
+      stream,
+      async (source) => await first(source)
+    )
+    const end = Date.now()
+
+    if (result == null || !uint8ArrayEquals(data, result)) {
+      throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+    }
+
+    return end - start
+  }
+}

package/src/pnet/README.md

@@ -20,7 +20,7 @@ js-libp2p-pnet
 ## Usage
 
 ```js
-const Protector = require('libp2p-pnet')
+const Protector from 'libp2p-pnet')
 const protector = new Protector(swarmKeyBuffer)
 const privateConnection = protector.protect(myPublicConnection, (err) => { })
 ```
@@ -63,7 +63,7 @@ node -e "require('libp2p/src/pnet').generate(process.stdout)" > swarm.key
 #### Programmatically
 
 ```js
-const writeKey = require('libp2p/src/pnet').generate
+const writeKey from 'libp2p/src/pnet').generate
 const swarmKey = new Uint8Array(95)
 writeKey(swarmKey)
 fs.writeFileSync('swarm.key', swarmKey)

package/src/pnet/crypto.ts

@@ -0,0 +1,67 @@
+import { logger } from '@libp2p/logger'
+import * as Errors from './errors.js'
+import xsalsa20 from 'xsalsa20'
+import { KEY_LENGTH } from './key-generator.js'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Source } from 'it-stream-types'
+
+const log = logger('libp2p:pnet')
+
+/**
+ * Creates a stream iterable to encrypt messages in a private network
+ */
+export function createBoxStream (nonce: Uint8Array, psk: Uint8Array) {
+  const xor = xsalsa20(nonce, psk)
+
+  return (source: Source<Uint8Array>) => (async function * () {
+    for await (const chunk of source) {
+      yield Uint8Array.from(xor.update(chunk.slice()))
+    }
+  })()
+}
+
+/**
+ * Creates a stream iterable to decrypt messages in a private network
+ */
+export function createUnboxStream (nonce: Uint8Array, psk: Uint8Array) {
+  return (source: Source<Uint8Array>) => (async function * () {
+    const xor = xsalsa20(nonce, psk)
+    log.trace('Decryption enabled')
+
+    for await (const chunk of source) {
+      yield Uint8Array.from(xor.update(chunk.slice()))
+    }
+  })()
+}
+
+/**
+ * Decode the version 1 psk from the given Uint8Array
+ */
+export function decodeV1PSK (pskBuffer: Uint8Array) {
+  try {
+    // This should pull from multibase/multicodec to allow for
+    // more encoding flexibility. Ideally we'd consume the codecs
+    // from the buffer line by line to evaluate the next line
+    // programmatically instead of making assumptions about the
+    // encodings of each line.
+    const metadata = uint8ArrayToString(pskBuffer).split(/(?:\r\n|\r|\n)/g)
+    const pskTag = metadata.shift()
+    const codec = metadata.shift()
+    const pskString = metadata.shift()
+    const psk = uint8ArrayFromString(pskString ?? '', 'base16')
+
+    if (psk.byteLength !== KEY_LENGTH) {
+      throw new Error(Errors.INVALID_PSK)
+    }
+
+    return {
+      tag: pskTag,
+      codecName: codec,
+      psk: psk
+    }
+  } catch (err: any) {
+    log.error(err)
+    throw new Error(Errors.INVALID_PSK)
+  }
+}

package/src/pnet/errors.ts

@@ -0,0 +1,5 @@
+export const INVALID_PEER = 'Not a valid peer connection'
+export const INVALID_PSK = 'Your private shared key is invalid'
+export const NO_LOCAL_ID = 'No local private key provided'
+export const NO_HANDSHAKE_CONNECTION = 'No connection for the handshake provided'
+export const STREAM_ENDED = 'Stream ended prematurely'