libp2p 0.36.2 → 0.37.0

package/src/circuit/auto-relay.ts

@@ -0,0 +1,286 @@
+import { logger } from '@libp2p/logger'
+import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { RELAY_CODEC } from './multicodec.js'
+import { canHop } from './circuit/hop.js'
+import { namespaceToCid } from './utils.js'
+import {
+  CIRCUIT_PROTO_CODE,
+  HOP_METADATA_KEY,
+  HOP_METADATA_VALUE,
+  RELAY_RENDEZVOUS_NS
+} from './constants.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interfaces/peer-store'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { Components } from '@libp2p/interfaces/components'
+import sort from 'it-sort'
+import all from 'it-all'
+import { pipe } from 'it-pipe'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+
+const log = logger('libp2p:auto-relay')
+
+const noop = () => {}
+
+export interface AutoRelayInit {
+  addressSorter?: AddressSorter
+  maxListeners?: number
+  onError?: (error: Error, msg?: string) => void
+}
+
+export class AutoRelay {
+  private readonly components: Components
+  private readonly addressSorter: AddressSorter
+  private readonly maxListeners: number
+  private readonly listenRelays: Set<string>
+  private readonly onError: (error: Error, msg?: string) => void
+
+  constructor (components: Components, init: AutoRelayInit) {
+    this.components = components
+    this.addressSorter = init.addressSorter ?? publicAddressesFirst
+    this.maxListeners = init.maxListeners ?? 1
+    this.listenRelays = new Set()
+    this.onError = init.onError ?? noop
+
+    this._onProtocolChange = this._onProtocolChange.bind(this)
+    this._onPeerDisconnected = this._onPeerDisconnected.bind(this)
+
+    this.components.getPeerStore().addEventListener('change:protocols', (evt) => {
+      void this._onProtocolChange(evt).catch(err => {
+        log.error(err)
+      })
+    })
+    this.components.getConnectionManager().addEventListener('peer:disconnect', this._onPeerDisconnected)
+  }
+
+  /**
+   * Check if a peer supports the relay protocol.
+   * If the protocol is not supported, check if it was supported before and remove it as a listen relay.
+   * If the protocol is supported, check if the peer supports **HOP** and add it as a listener if
+   * inside the threshold.
+   */
+  async _onProtocolChange (evt: CustomEvent<PeerProtocolsChangeData>) {
+    const {
+      peerId,
+      protocols
+    } = evt.detail
+    const id = peerId.toString()
+
+    // Check if it has the protocol
+    const hasProtocol = protocols.find(protocol => protocol === RELAY_CODEC)
+
+    // If no protocol, check if we were keeping the peer before as a listenRelay
+    if (hasProtocol == null) {
+      if (this.listenRelays.has(id)) {
+        await this._removeListenRelay(id)
+      }
+
+      return
+    }
+
+    if (this.listenRelays.has(id)) {
+      return
+    }
+
+    // If protocol, check if can hop, store info in the metadataBook and listen on it
+    try {
+      const connections = this.components.getConnectionManager().getConnections(peerId)
+
+      if (connections.length === 0) {
+        return
+      }
+
+      const connection = connections[0]
+
+      // Do not hop on a relayed connection
+      if (connection.remoteAddr.protoCodes().includes(CIRCUIT_PROTO_CODE)) {
+        log(`relayed connection to ${id} will not be used to hop on`)
+        return
+      }
+
+      const supportsHop = await canHop({ connection })
+
+      if (supportsHop) {
+        await this.components.getPeerStore().metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
+        await this._addListenRelay(connection, id)
+      }
+    } catch (err: any) {
+      this.onError(err)
+    }
+  }
+
+  /**
+   * Peer disconnects
+   */
+  _onPeerDisconnected (evt: CustomEvent<Connection>) {
+    const connection = evt.detail
+    const peerId = connection.remotePeer
+    const id = peerId.toString()
+
+    // Not listening on this relay
+    if (!this.listenRelays.has(id)) {
+      return
+    }
+
+    this._removeListenRelay(id).catch(err => {
+      log.error(err)
+    })
+  }
+
+  /**
+   * Attempt to listen on the given relay connection
+   */
+  async _addListenRelay (connection: Connection, id: string): Promise<void> {
+    try {
+      // Check if already listening on enough relays
+      if (this.listenRelays.size >= this.maxListeners) {
+        return
+      }
+
+      // Get peer known addresses and sort them with public addresses first
+      const remoteAddrs = await pipe(
+        await this.components.getPeerStore().addressBook.get(connection.remotePeer),
+        (source) => sort(source, this.addressSorter),
+        async (source) => await all(source)
+      )
+
+      // Attempt to listen on relay
+      const result = await Promise.all(
+        remoteAddrs.map(async addr => {
+          try {
+            let multiaddr = addr.multiaddr
+
+            if (multiaddr.getPeerId() == null) {
+              multiaddr = multiaddr.encapsulate(`/p2p/${connection.remotePeer.toString()}`)
+            }
+
+            multiaddr = multiaddr.encapsulate('/p2p-circuit')
+
+            // Announce multiaddrs will update on listen success by TransportManager event being triggered
+            await this.components.getTransportManager().listen([multiaddr])
+            return true
+          } catch (err: any) {
+            log.error('error listening on circuit address', err)
+            this.onError(err)
+          }
+
+          return false
+        })
+      )
+
+      if (result.includes(true)) {
+        this.listenRelays.add(id)
+      }
+    } catch (err: any) {
+      this.onError(err)
+      this.listenRelays.delete(id)
+    }
+  }
+
+  /**
+   * Remove listen relay
+   */
+  async _removeListenRelay (id: string) {
+    if (this.listenRelays.delete(id)) {
+      // TODO: this should be responsibility of the connMgr
+      await this._listenOnAvailableHopRelays([id])
+    }
+  }
+
+  /**
+   * Try to listen on available hop relay connections.
+   * The following order will happen while we do not have enough relays.
+   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected.
+   * 2. Dial and try to listen on the peers we know that support hop but are not connected.
+   * 3. Search the network.
+   */
+  async _listenOnAvailableHopRelays (peersToIgnore: string[] = []) {
+    // TODO: The peer redial issue on disconnect should be handled by connection gating
+    // Check if already listening on enough relays
+    if (this.listenRelays.size >= this.maxListeners) {
+      return
+    }
+
+    const knownHopsToDial = []
+    const peers = await this.components.getPeerStore().all()
+
+    // Check if we have known hop peers to use and attempt to listen on the already connected
+    for (const { id, metadata } of peers) {
+      const idStr = id.toString()
+
+      // Continue to next if listening on this or peer to ignore
+      if (this.listenRelays.has(idStr)) {
+        continue
+      }
+
+      if (peersToIgnore.includes(idStr)) {
+        continue
+      }
+
+      const supportsHop = metadata.get(HOP_METADATA_KEY)
+
+      // Continue to next if it does not support Hop
+      if ((supportsHop == null) || uint8ArrayToString(supportsHop) !== HOP_METADATA_VALUE) {
+        continue
+      }
+
+      const connections = this.components.getConnectionManager().getConnections(id)
+
+      // If not connected, store for possible later use.
+      if (connections.length === 0) {
+        knownHopsToDial.push(id)
+        continue
+      }
+
+      await this._addListenRelay(connections[0], idStr)
+
+      // Check if already listening on enough relays
+      if (this.listenRelays.size >= this.maxListeners) {
+        return
+      }
+    }
+
+    // Try to listen on known peers that are not connected
+    for (const peerId of knownHopsToDial) {
+      await this._tryToListenOnRelay(peerId)
+
+      // Check if already listening on enough relays
+      if (this.listenRelays.size >= this.maxListeners) {
+        return
+      }
+    }
+
+    // Try to find relays to hop on the network
+    try {
+      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+      for await (const provider of this.components.getContentRouting().findProviders(cid)) {
+        if (provider.multiaddrs.length === 0) {
+          continue
+        }
+
+        const peerId = provider.id
+        await this.components.getPeerStore().addressBook.add(peerId, provider.multiaddrs)
+
+        await this._tryToListenOnRelay(peerId)
+
+        // Check if already listening on enough relays
+        if (this.listenRelays.size >= this.maxListeners) {
+          return
+        }
+      }
+    } catch (err: any) {
+      this.onError(err)
+    }
+  }
+
+  async _tryToListenOnRelay (peerId: PeerId) {
+    try {
+      const connection = await this.components.getConnectionManager().openConnection(peerId)
+      await this._addListenRelay(connection, peerId.toString())
+    } catch (err: any) {
+      log.error('Could not use %p as relay', peerId, err)
+      this.onError(err, `could not connect and listen on known hop relay ${peerId.toString()}`)
+    }
+  }
+}

package/src/circuit/circuit/hop.ts

@@ -0,0 +1,211 @@
+import { logger } from '@libp2p/logger'
+import errCode from 'err-code'
+import { validateAddrs } from './utils.js'
+import { StreamHandler } from './stream-handler.js'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
+import { pipe } from 'it-pipe'
+import { codes as Errors } from '../../errors.js'
+import { stop } from './stop.js'
+import { RELAY_CODEC } from '../multicodec.js'
+import type { Connection } from '@libp2p/interfaces/connection'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import type { Duplex } from 'it-stream-types'
+import type { Circuit } from '../transport.js'
+import type { ConnectionManager } from '@libp2p/interfaces/connection-manager'
+
+const log = logger('libp2p:circuit:hop')
+
+export interface HopRequest {
+  connection: Connection
+  request: CircuitPB
+  streamHandler: StreamHandler
+  circuit: Circuit
+  connectionManager: ConnectionManager
+}
+
+export async function handleHop (hopRequest: HopRequest) {
+  const {
+    connection,
+    request,
+    streamHandler,
+    circuit,
+    connectionManager
+  } = hopRequest
+
+  // Ensure hop is enabled
+  if (!circuit.hopEnabled()) {
+    log('HOP request received but we are not acting as a relay')
+    return streamHandler.end({
+      type: CircuitPB.Type.STATUS,
+      code: CircuitPB.Status.HOP_CANT_SPEAK_RELAY
+    })
+  }
+
+  // Validate the HOP request has the required input
+  try {
+    validateAddrs(request, streamHandler)
+  } catch (err: any) {
+    log.error('invalid hop request via peer %p %o', connection.remotePeer, err)
+
+    return
+  }
+
+  if (request.dstPeer == null) {
+    log('HOP request received but we do not receive a dstPeer')
+    return
+  }
+
+  // Get the connection to the destination (stop) peer
+  const destinationPeer = peerIdFromBytes(request.dstPeer.id)
+
+  const destinationConnections = connectionManager.getConnections(destinationPeer)
+  if (destinationConnections.length === 0 && !circuit.hopActive()) {
+    log('HOP request received but we are not connected to the destination peer')
+    return streamHandler.end({
+      type: CircuitPB.Type.STATUS,
+      code: CircuitPB.Status.HOP_NO_CONN_TO_DST
+    })
+  }
+
+  // TODO: Handle being an active relay
+  if (destinationConnections.length === 0) {
+    log('did not have connection to remote peer')
+    return streamHandler.end({
+      type: CircuitPB.Type.STATUS,
+      code: CircuitPB.Status.HOP_NO_CONN_TO_DST
+    })
+  }
+
+  // Handle the incoming HOP request by performing a STOP request
+  const stopRequest = {
+    type: CircuitPB.Type.STOP,
+    dstPeer: request.dstPeer,
+    srcPeer: request.srcPeer
+  }
+
+  let destinationStream: Duplex<Uint8Array>
+  try {
+    log('performing STOP request')
+    const result = await stop({
+      connection: destinationConnections[0],
+      request: stopRequest
+    })
+
+    if (result == null) {
+      throw new Error('Could not stop')
+    }
+
+    destinationStream = result
+  } catch (err: any) {
+    log.error(err)
+
+    return
+  }
+
+  log('hop request from %p is valid', connection.remotePeer)
+  streamHandler.write({
+    type: CircuitPB.Type.STATUS,
+    code: CircuitPB.Status.SUCCESS
+  })
+  const sourceStream = streamHandler.rest()
+
+  log('creating related connections')
+  // Short circuit the two streams to create the relayed connection
+  return await pipe(
+    sourceStream,
+    destinationStream,
+    sourceStream
+  )
+}
+
+export interface HopConfig {
+  connection: Connection
+  request: CircuitPB
+}
+
+/**
+ * Performs a HOP request to a relay peer, to request a connection to another
+ * peer. A new, virtual, connection will be created between the two via the relay.
+ */
+export async function hop (options: HopConfig): Promise<Duplex<Uint8Array>> {
+  const {
+    connection,
+    request
+  } = options
+
+  // Create a new stream to the relay
+  const { stream } = await connection.newStream(RELAY_CODEC)
+  // Send the HOP request
+  const streamHandler = new StreamHandler({ stream })
+  streamHandler.write(request)
+
+  const response = await streamHandler.read()
+
+  if (response == null) {
+    throw errCode(new Error('HOP request had no response'), Errors.ERR_HOP_REQUEST_FAILED)
+  }
+
+  if (response.code === CircuitPB.Status.SUCCESS) {
+    log('hop request was successful')
+    return streamHandler.rest()
+  }
+
+  log('hop request failed with code %d, closing stream', response.code)
+  streamHandler.close()
+
+  throw errCode(new Error(`HOP request failed with code "${response.code ?? 'unknown'}"`), Errors.ERR_HOP_REQUEST_FAILED)
+}
+
+export interface CanHopOptions {
+  connection: Connection
+}
+
+/**
+ * Performs a CAN_HOP request to a relay peer, in order to understand its capabilities
+ */
+export async function canHop (options: CanHopOptions) {
+  const {
+    connection
+  } = options
+
+  // Create a new stream to the relay
+  const { stream } = await connection.newStream(RELAY_CODEC)
+
+  // Send the HOP request
+  const streamHandler = new StreamHandler({ stream })
+  streamHandler.write({
+    type: CircuitPB.Type.CAN_HOP
+  })
+
+  const response = await streamHandler.read()
+  await streamHandler.close()
+
+  if (response == null || response.code !== CircuitPB.Status.SUCCESS) {
+    return false
+  }
+
+  return true
+}
+
+export interface HandleCanHopOptions {
+  connection: Connection
+  streamHandler: StreamHandler
+  circuit: Circuit
+}
+
+/**
+ * Creates an unencoded CAN_HOP response based on the Circuits configuration
+ */
+export function handleCanHop (options: HandleCanHopOptions) {
+  const {
+    connection,
+    streamHandler,
+    circuit
+  } = options
+  const canHop = circuit.hopEnabled()
+  log('can hop (%s) request from %p', canHop, connection.remotePeer)
+  streamHandler.end({
+    type: CircuitPB.Type.STATUS,
+    code: canHop ? CircuitPB.Status.SUCCESS : CircuitPB.Status.HOP_CANT_SPEAK_RELAY
+  })
+}

package/src/circuit/circuit/stop.ts

@@ -0,0 +1,78 @@
+import { logger } from '@libp2p/logger'
+import { CircuitRelay as CircuitPB } from '../pb/index.js'
+import { RELAY_CODEC } from '../multicodec.js'
+import { StreamHandler } from './stream-handler.js'
+import { validateAddrs } from './utils.js'
+import type { Connection } from '@libp2p/interfaces/connection'
+import type { Duplex } from 'it-stream-types'
+
+const log = logger('libp2p:circuit:stop')
+
+export interface HandleStopOptions {
+  connection: Connection
+  request: CircuitPB
+  streamHandler: StreamHandler
+}
+
+/**
+ * Handles incoming STOP requests
+ */
+export function handleStop (options: HandleStopOptions): Duplex<Uint8Array> | undefined {
+  const {
+    connection,
+    request,
+    streamHandler
+  } = options
+
+  // Validate the STOP request has the required input
+  try {
+    validateAddrs(request, streamHandler)
+  } catch (err: any) {
+    log.error('invalid stop request via peer %p %o', connection.remotePeer, err)
+    return
+  }
+
+  // The request is valid
+  log('stop request is valid')
+  streamHandler.write({
+    type: CircuitPB.Type.STATUS,
+    code: CircuitPB.Status.SUCCESS
+  })
+
+  return streamHandler.rest()
+}
+
+export interface StopOptions {
+  connection: Connection
+  request: CircuitPB
+}
+
+/**
+ * Creates a STOP request
+ */
+export async function stop (options: StopOptions) {
+  const {
+    connection,
+    request
+  } = options
+
+  const { stream } = await connection.newStream([RELAY_CODEC])
+  log('starting stop request to %p', connection.remotePeer)
+  const streamHandler = new StreamHandler({ stream })
+
+  streamHandler.write(request)
+  const response = await streamHandler.read()
+
+  if (response == null) {
+    streamHandler.close()
+    return
+  }
+
+  if (response.code === CircuitPB.Status.SUCCESS) {
+    log('stop request to %p was successful', connection.remotePeer)
+    return streamHandler.rest()
+  }
+
+  log('stop request failed with code %d', response.code)
+  streamHandler.close()
+}

package/src/circuit/circuit/stream-handler.ts

@@ -0,0 +1,86 @@
+import { logger } from '@libp2p/logger'
+import * as lp from 'it-length-prefixed'
+import { Handshake, handshake } from 'it-handshake'
+import { CircuitRelay } from '../pb/index.js'
+import type { Stream } from '@libp2p/interfaces/connection'
+import type { Source } from 'it-stream-types'
+
+const log = logger('libp2p:circuit:stream-handler')
+
+export interface StreamHandlerOptions {
+  /**
+   * A duplex iterable
+   */
+  stream: Stream
+
+  /**
+   * max bytes length of message
+   */
+  maxLength?: number
+}
+
+export class StreamHandler {
+  private readonly stream: Stream
+  private readonly shake: Handshake
+  private readonly decoder: Source<Uint8Array>
+
+  constructor (options: StreamHandlerOptions) {
+    const { stream, maxLength = 4096 } = options
+
+    this.stream = stream
+    this.shake = handshake(this.stream)
+    this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength })
+  }
+
+  /**
+   * Read and decode message
+   */
+  async read () {
+    // @ts-expect-error FIXME is a source, needs to be a generator
+    const msg = await this.decoder.next()
+
+    if (msg.value != null) {
+      const value = CircuitRelay.decode(msg.value.slice())
+      log('read message type', value.type)
+      return value
+    }
+
+    log('read received no value, closing stream')
+    // End the stream, we didn't get data
+    this.close()
+  }
+
+  /**
+   * Encode and write array of buffers
+   */
+  write (msg: CircuitRelay) {
+    log('write message type %s', msg.type)
+    this.shake.write(lp.encode.single(CircuitRelay.encode(msg)).slice())
+  }
+
+  /**
+   * Return the handshake rest stream and invalidate handler
+   */
+  rest () {
+    this.shake.rest()
+    return this.shake.stream
+  }
+
+  /**
+   * @param {CircuitRelay} msg - An unencoded CircuitRelay protobuf message
+   */
+  end (msg: CircuitRelay) {
+    this.write(msg)
+    this.close()
+  }
+
+  /**
+   * Close the stream
+   */
+  close () {
+    log('closing the stream')
+    void this.rest().sink([]).catch(err => {
+      log.error(err)
+    })
+  }
+}