libp2p 0.42.2-f6f73a21 → 0.43.0

package/src/circuit/README.md

@@ -1,111 +0,0 @@
-# js-libp2p-circuit
-
-> Node.js implementation of the Circuit module that libp2p uses, which implements the [interface-connection](https://github.com/libp2p/js-libp2p-interfaces/tree/master/src/connection) interface for dial/listen.
-
-**Note**: git history prior to merging into js-libp2p can be found in the original repository, https://github.com/libp2p/js-libp2p-circuit.
-
-`libp2p-circuit` implements the circuit-relay mechanism that allows nodes that don't speak the same protocol to communicate using a third _relay_ node. You can read more about this in its [spec](https://github.com/libp2p/specs/tree/master/relay).
-
-## Table of Contents
-
-- [js-libp2p-circuit](#js-libp2p-circuit)
-  - [Table of Contents](#table-of-contents)
-    - [Why?](#why)
-    - [libp2p-circuit and IPFS](#libp2p-circuit-and-ipfs)
-  - [Usage](#usage)
-  - [API](#api)
-    - [Implementation rational](#implementation-rational)
-
-### Why?
-
-`circuit-relaying` uses additional nodes in order to transfer traffic between two otherwise unreachable nodes. This allows nodes that don't speak the same protocols or are running in limited environments, e.g. browsers and IoT devices, to communicate, which would otherwise be impossible given the fact that for example browsers don't have any socket support and as such cannot be directly dialed.
-
-The use of circuit-relaying is not limited to routing traffic between browser nodes, other uses include:
- - routing traffic between private nets and circumventing NAT layers
- - route mangling for better privacy (matreshka/shallot dialing).
-
-It's also possible to use it for clients that implement exotic transports such as  devices that only have bluetooth radios to be reachable over bluetooth enabled relays and become full p2p nodes.
-
-### libp2p-circuit and IPFS
-
-Prior to `libp2p-circuit` there was a rift in the IPFS network, were IPFS nodes could only access content from nodes that speak the same protocol, for example TCP only nodes could only dial to other TCP only nodes, same for any other protocol combination. In practice, this limitation was most visible in JS-IPFS browser nodes, since they can only dial out but not be dialed in over WebRTC or WebSockets, hence any content that the browser node held was not reachable by the rest of the network even through it was announced on the DHT. Non browser IPFS nodes would usually speak more than one protocol such as TCP, WebSockets and/or WebRTC, this made the problem less severe outside of the browser. `libp2p-circuit` solves this problem completely, as long as there are `relay nodes` capable of routing traffic between those nodes their content should be available to the rest of the IPFS network.
-
-## Usage
-
-Libp2p circuit configuration can be seen at [Setup with Relay](../../doc/CONFIGURATION.md#setup-with-relay).
-
-Once you have a circuit relay node running, you can configure other nodes to use it as a relay as follows:
-
-```js
-import { multiaddr } from '@multiformats/multiaddr'
-import Libp2p from 'libp2p'
-import { tcp } from '@libp2p/tcp'
-import { mplex } from '@libp2p/mplex'
-import { noise } from '@chainsafe/libp2p-noise'
-
-const relayAddr = ...
-
-const node = await createLibp2p({
-  addresses: {
-    listen: [multiaddr(`${relayAddr}/p2p-circuit`)]
-  },
-  transports: [
-    tcp()
-  ],
-  streamMuxers: [
-    mplex()
-    ],
-  connectionEncryption: [
-    noise()
-  ]
-  },
-  config: {
-    relay: {                   // Circuit Relay options (this config is part of libp2p core configurations)
-      enabled: true           // Allows you to dial and accept relayed connections. Does not make you a relay.
-    }
-  }
-})
-```
-
-## API
-
-[![](https://raw.githubusercontent.com/libp2p/interface-transport/master/img/badge.png)](https://github.com/libp2p/interface-transport)
-
-`libp2p-circuit` accepts Circuit addresses for both IPFS and non IPFS encapsulated addresses, i.e:
-
-`/p2p-circuit/ip4/127.0.0.1/tcp/4001/p2p/QmHash`
-
-Both for dialing and listening.
-
-### Implementation rational
-
-This module is not a transport, however it implements `interface-transport` interface in order to allow circuit to be plugged with `libp2p`. The rational behind it is that, `libp2p-circuit` has a dial and listen flow, which fits nicely with other transports, moreover, it requires the _raw_ connection to be encrypted and muxed just as a regular transport's connection does. All in all, `interface-transport` ended up being the correct level of abstraction for circuit, as well as allowed us to reuse existing integration points in `libp2p` and `libp2p` without adding any ad-hoc logic. All parts of `interface-transport` are used, including `.getAddr` which returns a list of `/p2p-circuit` addresses that circuit is currently listening.
-
-```
-libp2p                                                                                  libp2p-circuit (transport)
-+-------------------------------------------------+                                     +--------------------------+
-|        +---------------------------------+      |                                     |                          |
-|        |                                 |      |                                     |   +------------------+   |
-|        |                                 |      |  circuit-relay listens for the HOP  |   |                  |   |
-|        |              libp2p             <------------------------------------------------|  circuit-relay   |   |
-|        |                                 |      |  message to handle incomming relay  |   |                  |   |
-|        |                                 |      |  requests from other nodes          |   +------------------+   |
-|        +---------------------------------+      |                                     |                          |
-|         ^     ^   ^  ^   ^           ^          |                                     |   +------------------+   |
-|         |     |   |  |   |           |          |                                     |   | +-------------+  |   |
-|         |     |   |  |   |           |          |      dialer uses libp2p to dial     |   | |             |  |   |
-|         |     |   |  +---------------------------------------------------------------------->   dialer    |  |   |
-|         |     | transports           |          |  to a circuit-relay node using the  |   | |             |  |   |
-|         |     |   |      |           |          |  HOP message                        |   | +-------------+  |   |
-|         |     |   |      |           |          |                                     |   |                  |   |
-|         v     v   |      v           v          |                                     |   |                  |   |
-|+------------------|----------------------------+|                                     |   |  +-------------+ |   |
-||           |      |    |      |                ||                                     |   |  |             | |   |
-||libp2p-tcp |libp2p-ws  | .... |libp2p-circuit  ||  listener handles STOP messages from|   |  | listener    | |   |
-||           |      +-------------------------------------------------------------------------->             | |   |
-||           |           |      |plugs in just   ||  circuit-relay nodes                |   |  +-------------+ |   |
-||           |           |      |as any other    ||                                     |   |                  |   |
-||           |           |      |transport       ||                                     |   +------------------+   |
-|+-----------------------------------------------+|                                     |                          |
-+-------------------------------------------------+                                     +--------------------------+
-```

package/src/circuit/auto-relay.ts

@@ -1,292 +0,0 @@
-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/interface-peer-id'
-import type { AddressSorter, PeerProtocolsChangeData } from '@libp2p/interface-peer-store'
-import type { Connection } from '@libp2p/interface-connection'
-import sort from 'it-sort'
-import all from 'it-all'
-import { pipe } from 'it-pipe'
-import { publicAddressesFirst } from '@libp2p/utils/address-sort'
-import type { RelayComponents } from './index.js'
-
-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: RelayComponents
-  private readonly addressSorter: AddressSorter
-  private readonly maxListeners: number
-  private readonly listenRelays: Set<string>
-  private readonly onError: (error: Error, msg?: string) => void
-
-  constructor (components: RelayComponents, 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.peerStore.addEventListener('change:protocols', (evt) => {
-      void this._onProtocolChange(evt).catch(err => {
-        log.error(err)
-      })
-    })
-    this.components.connectionManager.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.connectionManager.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.peerStore.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.peerStore.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.transportManager.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.peerStore.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.connectionManager.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.contentRouting.findProviders(cid)) {
-        if (provider.multiaddrs.length === 0) {
-          continue
-        }
-
-        const peerId = provider.id
-
-        if (peerId.equals(this.components.peerId)) {
-          // Skip the provider if it's us as dialing will fail
-          continue
-        }
-
-        await this.components.peerStore.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.connectionManager.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

@@ -1,220 +0,0 @@
-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/interface-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/interface-connection-manager'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-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): Promise<void> {
-  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<Uint8ArrayList>
-  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 extends AbortOptions {
-  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<Uint8ArrayList, Uint8ArrayList | Uint8Array>> {
-  const {
-    connection,
-    request,
-    signal
-  } = options
-
-  // Create a new stream to the relay
-  const stream = await connection.newStream(RELAY_CODEC, {
-    signal
-  })
-  // 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 extends AbortOptions {
-  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,
-    signal
-  } = options
-
-  // Create a new stream to the relay
-  const stream = await connection.newStream(RELAY_CODEC, {
-    signal
-  })
-
-  // 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
-  })
-}