libp2p 0.36.2 → 0.37.0

package/src/pnet/index.ts

@@ -0,0 +1,97 @@
+import { logger } from '@libp2p/logger'
+import { pipe } from 'it-pipe'
+import errCode from 'err-code'
+import { duplexPair } from 'it-pair/duplex'
+import { randomBytes } from '@libp2p/crypto'
+import * as Errors from './errors.js'
+import { codes } from '../errors.js'
+import {
+  createBoxStream,
+  createUnboxStream,
+  decodeV1PSK
+} from './crypto.js'
+import { handshake } from 'it-handshake'
+import { NONCE_LENGTH } from './key-generator.js'
+import type { MultiaddrConnection } from '@libp2p/interfaces/transport'
+import type { ConnectionProtector } from '@libp2p/interfaces/connection'
+
+const log = logger('libp2p:pnet')
+
+export { generateKey } from './key-generator.js'
+
+export interface ProtectorInit {
+  enabled?: boolean
+  psk: Uint8Array
+}
+
+export class PreSharedKeyConnectionProtector implements ConnectionProtector {
+  public tag: string
+  private readonly psk: Uint8Array
+  private readonly enabled: boolean
+
+  /**
+   * Takes a Private Shared Key (psk) and provides a `protect` method
+   * for wrapping existing connections in a private encryption stream.
+   */
+  constructor (init: ProtectorInit) {
+    this.enabled = init.enabled !== false
+
+    if (this.enabled) {
+      const decodedPSK = decodeV1PSK(init.psk)
+      this.psk = decodedPSK.psk
+      this.tag = decodedPSK.tag ?? ''
+    } else {
+      this.psk = new Uint8Array()
+      this.tag = ''
+    }
+  }
+
+  /**
+   * Takes a given Connection and creates a private encryption stream
+   * between its two peers from the PSK the Protector instance was
+   * created with.
+   */
+  async protect (connection: MultiaddrConnection): Promise<MultiaddrConnection> {
+    if (!this.enabled) {
+      return connection
+    }
+
+    if (connection == null) {
+      throw errCode(new Error(Errors.NO_HANDSHAKE_CONNECTION), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    // Exchange nonces
+    log('protecting the connection')
+    const localNonce = randomBytes(NONCE_LENGTH)
+
+    const shake = handshake(connection)
+    shake.write(localNonce)
+
+    const result = await shake.reader.next(NONCE_LENGTH)
+
+    if (result.value == null) {
+      throw errCode(new Error(Errors.STREAM_ENDED), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const remoteNonce = result.value.slice()
+    shake.rest()
+
+    // Create the boxing/unboxing pipe
+    log('exchanged nonces')
+    const [internal, external] = duplexPair<Uint8Array>()
+    pipe(
+      external,
+      // Encrypt all outbound traffic
+      createBoxStream(localNonce, this.psk),
+      shake.stream,
+      // Decrypt all inbound traffic
+      createUnboxStream(remoteNonce, this.psk),
+      external
+    ).catch(log.error)
+
+    return {
+      ...connection,
+      ...internal
+    }
+  }
+}

package/src/pnet/key-generator.ts

@@ -0,0 +1,28 @@
+import { randomBytes } from '@libp2p/crypto'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+
+/**
+ * Generates a PSK that can be used in a libp2p-pnet private network
+ *
+ * @param {Uint8Array} bytes - An object to write the psk into
+ * @returns {void}
+ */
+export function generateKey (bytes: Uint8Array) {
+  const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
+  const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
+
+  bytes.set(key)
+}
+
+export const NONCE_LENGTH = 24
+export const KEY_LENGTH = 32
+
+try {
+  if (require.main === module) {
+    // @ts-expect-error
+    generate(process.stdout)
+  }
+} catch (error: any) {
+
+}

package/src/pubsub/dummy-pubsub.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from '@libp2p/interfaces/events'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { PublishResult, PubSub, PubSubEvents, StrictNoSign, StrictSign } from '@libp2p/interfaces/pubsub'
+import errCode from 'err-code'
+import { messages, codes } from '../errors.js'
+
+export class DummyPubSub extends EventEmitter<PubSubEvents> implements PubSub {
+  isStarted (): boolean {
+    return false
+  }
+
+  start (): void | Promise<void> {
+
+  }
+
+  stop (): void | Promise<void> {
+
+  }
+
+  get globalSignaturePolicy (): typeof StrictSign | typeof StrictNoSign {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  get multicodecs (): string[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getPeers (): PeerId[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getTopics (): string[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  subscribe (): void {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  unsubscribe (): void {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  getSubscribers (): PeerId[] {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+
+  async publish (): Promise<PublishResult> {
+    throw errCode(new Error(messages.PUBSUB_DISABLED), codes.ERR_PUBSUB_DISABLED)
+  }
+}

package/src/registrar.ts

@@ -0,0 +1,189 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { codes } from './errors.js'
+import { isTopology, Topology } from '@libp2p/interfaces/topology'
+import type { Registrar, StreamHandler } from '@libp2p/interfaces/registrar'
+import type { PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:registrar')
+
+function supportsProtocol (peerProtocols: string[], topologyProtocols: string[]) {
+  for (const peerProtocol of peerProtocols) {
+    if (topologyProtocols.includes(peerProtocol)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Responsible for notifying registered protocols of events in the network.
+ */
+export class DefaultRegistrar implements Registrar {
+  private readonly topologies: Map<string, { topology: Topology, protocols: string[] }>
+  private readonly handlers: Map<string, StreamHandler>
+  private readonly components: Components
+
+  constructor (components: Components) {
+    this.topologies = new Map()
+    this.handlers = new Map()
+    this.components = components
+
+    this._onDisconnect = this._onDisconnect.bind(this)
+    this._onProtocolChange = this._onProtocolChange.bind(this)
+
+    this.components.getConnectionManager().addEventListener('peer:disconnect', this._onDisconnect)
+
+    // happens after identify
+    this.components.getPeerStore().addEventListener('change:protocols', this._onProtocolChange)
+  }
+
+  getProtocols () {
+    const protocols = new Set<string>()
+
+    for (const topology of this.topologies.values()) {
+      topology.protocols.forEach(protocol => protocols.add(protocol))
+    }
+
+    for (const protocol of this.handlers.keys()) {
+      protocols.add(protocol)
+    }
+
+    return Array.from(protocols).sort()
+  }
+
+  getHandler (protocol: string) {
+    const handler = this.handlers.get(protocol)
+
+    if (handler == null) {
+      throw new Error(`No handler registered for protocol ${protocol}`)
+    }
+
+    return handler
+  }
+
+  getTopologies (protocol: string) {
+    const output: Topology[] = []
+
+    for (const { topology, protocols } of this.topologies.values()) {
+      if (protocols.includes(protocol)) {
+        output.push(topology)
+      }
+    }
+
+    return output
+  }
+
+  /**
+   * Registers the `handler` for each protocol
+   */
+  async handle (protocols: string | string[], handler: StreamHandler): Promise<void> {
+    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
+
+    for (const protocol of protocolList) {
+      if (this.handlers.has(protocol)) {
+        throw errCode(new Error(`Handler already registered for protocol ${protocol}`), codes.ERR_PROTOCOL_HANDLER_ALREADY_REGISTERED)
+      }
+
+      this.handlers.set(protocol, handler)
+    }
+
+    // Add new protocols to self protocols in the Protobook
+    await this.components.getPeerStore().protoBook.add(this.components.getPeerId(), protocolList)
+  }
+
+  /**
+   * Removes the handler for each protocol. The protocol
+   * will no longer be supported on streams.
+   */
+  async unhandle (protocols: string | string[]) {
+    const protocolList = Array.isArray(protocols) ? protocols : [protocols]
+
+    protocolList.forEach(protocol => {
+      this.handlers.delete(protocol)
+    })
+
+    // Remove protocols from self protocols in the Protobook
+    await this.components.getPeerStore().protoBook.remove(this.components.getPeerId(), protocolList)
+  }
+
+  /**
+   * Register handlers for a set of multicodecs given
+   */
+  async register (protocols: string | string[], topology: Topology): Promise<string> {
+    if (!isTopology(topology)) {
+      log.error('topology must be an instance of interfaces/topology')
+      throw errCode(new Error('topology must be an instance of interfaces/topology'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    // Create topology
+    const id = `${(Math.random() * 1e9).toString(36)}${Date.now()}`
+
+    this.topologies.set(id, {
+      topology,
+      protocols: Array.isArray(protocols) ? protocols : [protocols]
+    })
+
+    // Set registrar
+    await topology.setRegistrar(this)
+
+    return id
+  }
+
+  /**
+   * Unregister topology
+   */
+  unregister (id: string) {
+    this.topologies.delete(id)
+  }
+
+  /**
+   * Remove a disconnected peer from the record
+   */
+  _onDisconnect (evt: CustomEvent<Connection>) {
+    const connection = evt.detail
+
+    void this.components.getPeerStore().protoBook.get(connection.remotePeer)
+      .then(peerProtocols => {
+        for (const { topology, protocols } of this.topologies.values()) {
+          if (supportsProtocol(peerProtocols, protocols)) {
+            topology.onDisconnect(connection.remotePeer)
+          }
+        }
+      })
+      .catch(err => {
+        log.error(err)
+      })
+  }
+
+  /**
+   * Check if a new peer support the multicodecs for this topology
+   */
+  _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>) {
+    const { peerId, protocols, oldProtocols } = evt.detail
+
+    const removed = oldProtocols.filter(protocol => !protocols.includes(protocol))
+    const added = protocols.filter(protocol => !oldProtocols.includes(protocol))
+
+    for (const { topology, protocols } of this.topologies.values()) {
+      if (supportsProtocol(removed, protocols)) {
+        topology.onDisconnect(peerId)
+      }
+    }
+
+    for (const { topology, protocols } of this.topologies.values()) {
+      if (supportsProtocol(added, protocols)) {
+        const connection = this.components.getConnectionManager().getConnections(peerId)[0]
+
+        if (connection == null) {
+          continue
+        }
+
+        topology.onConnect(peerId, connection)
+      }
+    }
+  }
+}

package/src/transport-manager.ts

@@ -0,0 +1,281 @@
+import { logger } from '@libp2p/logger'
+import pSettle from 'p-settle'
+import { codes } from './errors.js'
+import errCode from 'err-code'
+import type { Listener, Transport, TransportManager, TransportManagerEvents } from '@libp2p/interfaces/transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { AbortOptions } from '@libp2p/interfaces'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Components } from '@libp2p/interfaces/components'
+import { trackedMap } from '@libp2p/tracked-map'
+
+const log = logger('libp2p:transports')
+
+export interface TransportManagerInit {
+  faultTolerance?: FaultTolerance
+}
+
+export class DefaultTransportManager extends EventEmitter<TransportManagerEvents> implements TransportManager, Startable {
+  private readonly components: Components
+  private readonly transports: Map<string, Transport>
+  private readonly listeners: Map<string, Listener[]>
+  private readonly faultTolerance: FaultTolerance
+  private started: boolean
+
+  constructor (components: Components, init: TransportManagerInit = {}) {
+    super()
+
+    this.components = components
+    this.started = false
+    this.transports = new Map<string, Transport>()
+    this.listeners = trackedMap({
+      component: 'transport-manager',
+      metric: 'listeners',
+      metrics: this.components.getMetrics()
+    })
+    this.faultTolerance = init.faultTolerance ?? FaultTolerance.FATAL_ALL
+  }
+
+  /**
+   * Adds a `Transport` to the manager
+   */
+  add (transport: Transport) {
+    const tag = transport[Symbol.toStringTag]
+
+    if (tag == null) {
+      throw errCode(new Error('Transport must have a valid tag'), codes.ERR_INVALID_KEY)
+    }
+
+    if (this.transports.has(tag)) {
+      throw errCode(new Error('There is already a transport with this tag'), codes.ERR_DUPLICATE_TRANSPORT)
+    }
+
+    log('adding transport %s', tag)
+
+    this.transports.set(tag, transport)
+
+    if (!this.listeners.has(tag)) {
+      this.listeners.set(tag, [])
+    }
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  async start () {
+    // Listen on the provided transports for the provided addresses
+    const addrs = this.components.getAddressManager().getListenAddrs()
+
+    await this.listen(addrs)
+
+    this.started = true
+  }
+
+  /**
+   * Stops all listeners
+   */
+  async stop () {
+    const tasks = []
+    for (const [key, listeners] of this.listeners) {
+      log('closing listeners for %s', key)
+      while (listeners.length > 0) {
+        const listener = listeners.pop()
+
+        if (listener == null) {
+          continue
+        }
+
+        tasks.push(listener.close())
+      }
+    }
+
+    await Promise.all(tasks)
+    log('all listeners closed')
+    for (const key of this.listeners.keys()) {
+      this.listeners.set(key, [])
+    }
+
+    this.started = false
+  }
+
+  /**
+   * Dials the given Multiaddr over it's supported transport
+   */
+  async dial (ma: Multiaddr, options?: AbortOptions): Promise<Connection> {
+    const transport = this.transportForMultiaddr(ma)
+
+    if (transport == null) {
+      throw errCode(new Error(`No transport available for address ${String(ma)}`), codes.ERR_TRANSPORT_UNAVAILABLE)
+    }
+
+    try {
+      return await transport.dial(ma, {
+        ...options,
+        upgrader: this.components.getUpgrader()
+      })
+    } catch (err: any) {
+      if (err.code == null) {
+        err.code = codes.ERR_TRANSPORT_DIAL_FAILED
+      }
+
+      throw err
+    }
+  }
+
+  /**
+   * Returns all Multiaddr's the listeners are using
+   */
+  getAddrs (): Multiaddr[] {
+    let addrs: Multiaddr[] = []
+    for (const listeners of this.listeners.values()) {
+      for (const listener of listeners) {
+        addrs = [...addrs, ...listener.getAddrs()]
+      }
+    }
+    return addrs
+  }
+
+  /**
+   * Returns all the transports instances
+   */
+  getTransports () {
+    return Array.of(...this.transports.values())
+  }
+
+  /**
+   * Finds a transport that matches the given Multiaddr
+   */
+  transportForMultiaddr (ma: Multiaddr) {
+    for (const transport of this.transports.values()) {
+      const addrs = transport.filter([ma])
+
+      if (addrs.length > 0) {
+        return transport
+      }
+    }
+  }
+
+  /**
+   * Starts listeners for each listen Multiaddr
+   */
+  async listen (addrs: Multiaddr[]) {
+    if (addrs == null || addrs.length === 0) {
+      log('no addresses were provided for listening, this node is dial only')
+      return
+    }
+
+    const couldNotListen = []
+
+    for (const [key, transport] of this.transports.entries()) {
+      const supportedAddrs = transport.filter(addrs)
+      const tasks = []
+
+      // For each supported multiaddr, create a listener
+      for (const addr of supportedAddrs) {
+        log('creating listener for %s on %s', key, addr)
+        const listener = transport.createListener({
+          upgrader: this.components.getUpgrader()
+        })
+
+        let listeners = this.listeners.get(key)
+
+        if (listeners == null) {
+          listeners = []
+          this.listeners.set(key, listeners)
+        }
+
+        listeners.push(listener)
+
+        // Track listen/close events
+        listener.addEventListener('listening', () => {
+          this.dispatchEvent(new CustomEvent<Listener>('listener:listening', {
+            detail: listener
+          }))
+        })
+        listener.addEventListener('close', () => {
+          this.dispatchEvent(new CustomEvent<Listener>('listener:close', {
+            detail: listener
+          }))
+        })
+
+        // We need to attempt to listen on everything
+        tasks.push(listener.listen(addr))
+      }
+
+      // Keep track of transports we had no addresses for
+      if (tasks.length === 0) {
+        couldNotListen.push(key)
+        continue
+      }
+
+      const results = await pSettle(tasks)
+      // If we are listening on at least 1 address, succeed.
+      // TODO: we should look at adding a retry (`p-retry`) here to better support
+      // listening on remote addresses as they may be offline. We could then potentially
+      // just wait for any (`p-any`) listener to succeed on each transport before returning
+      const isListening = results.find(r => r.isFulfilled)
+      if ((isListening == null) && this.faultTolerance !== FaultTolerance.NO_FATAL) {
+        throw errCode(new Error(`Transport (${key}) could not listen on any available address`), codes.ERR_NO_VALID_ADDRESSES)
+      }
+    }
+
+    // If no transports were able to listen, throw an error. This likely
+    // means we were given addresses we do not have transports for
+    if (couldNotListen.length === this.transports.size) {
+      const message = `no valid addresses were provided for transports [${couldNotListen.join(', ')}]`
+      if (this.faultTolerance === FaultTolerance.FATAL_ALL) {
+        throw errCode(new Error(message), codes.ERR_NO_VALID_ADDRESSES)
+      }
+      log(`libp2p in dial mode only: ${message}`)
+    }
+  }
+
+  /**
+   * Removes the given transport from the manager.
+   * If a transport has any running listeners, they will be closed.
+   */
+  async remove (key: string) {
+    log('removing %s', key)
+
+    // Close any running listeners
+    for (const listener of this.listeners.get(key) ?? []) {
+      await listener.close()
+    }
+
+    this.transports.delete(key)
+    this.listeners.delete(key)
+  }
+
+  /**
+   * Removes all transports from the manager.
+   * If any listeners are running, they will be closed.
+   *
+   * @async
+   */
+  async removeAll () {
+    const tasks = []
+    for (const key of this.transports.keys()) {
+      tasks.push(this.remove(key))
+    }
+
+    await Promise.all(tasks)
+  }
+}
+
+/**
+ * Enum Transport Manager Fault Tolerance values
+ */
+export enum FaultTolerance {
+  /**
+   * should be used for failing in any listen circumstance
+   */
+  FATAL_ALL = 0,
+
+  /**
+   * should be used for not failing when not listening
+   */
+  NO_FATAL
+}