libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/circuit/transport/index.ts

@@ -0,0 +1,325 @@
+import { StopMessage, HopMessage, Status } from '../pb/index.js'
+import { logger } from '@libp2p/logger'
+import createError from 'err-code'
+import * as mafmt from '@multiformats/mafmt'
+import { multiaddr } from '@multiformats/multiaddr'
+import { codes } from '../../errors.js'
+import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
+import { createListener } from './listener.js'
+import { symbol, Upgrader } from '@libp2p/interface-transport'
+import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { Listener, Transport, CreateListenerOptions } from '@libp2p/interface-transport'
+import type { Connection, Stream } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { AddressManager } from '@libp2p/interface-address-manager'
+import { pbStream } from 'it-pb-stream'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
+import { RelayStoreInit, ReservationStore } from './reservation-store.js'
+import { RelayDiscovery, RelayDiscoveryComponents } from './discovery.js'
+
+const log = logger('libp2p:circuit-relay:transport')
+
+const isValidStop = (request: StopMessage): request is Required<StopMessage> => {
+  if (request.peer == null) {
+    return false
+  }
+
+  try {
+    request.peer.addrs.forEach(multiaddr)
+  } catch {
+    return false
+  }
+
+  return true
+}
+
+export interface CircuitRelayTransportComponents extends RelayDiscoveryComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  registrar: Registrar
+  connectionManager: ConnectionManager
+  upgrader: Upgrader
+  addressManager: AddressManager
+  contentRouting: ContentRouting
+  connectionGater: ConnectionGater
+}
+
+interface ConnectOptions {
+  stream: Stream
+  connection: Connection
+  destinationPeer: PeerId
+  destinationAddr: Multiaddr
+  relayAddr: Multiaddr
+  ma: Multiaddr
+  disconnectOnFailure: boolean
+}
+
+/**
+ * RelayConfig configures the circuit v2 relay transport.
+ */
+export interface CircuitRelayTransportInit extends RelayStoreInit {
+  /**
+   * The number of peers running diable relays to search for and
+   * connect to. (default: 0)
+   */
+  discoverRelays?: number
+}
+
+class CircuitRelayTransport implements Transport {
+  private readonly discovery?: RelayDiscovery
+  private readonly registrar: Registrar
+  private readonly peerStore: PeerStore
+  private readonly connectionManager: ConnectionManager
+  private readonly peerId: PeerId
+  private readonly upgrader: Upgrader
+  private readonly addressManager: AddressManager
+  private readonly connectionGater: ConnectionGater
+  private readonly reservationStore: ReservationStore
+  private started: boolean
+
+  constructor (components: CircuitRelayTransportComponents, init: CircuitRelayTransportInit) {
+    this.registrar = components.registrar
+    this.peerStore = components.peerStore
+    this.connectionManager = components.connectionManager
+    this.peerId = components.peerId
+    this.upgrader = components.upgrader
+    this.addressManager = components.addressManager
+    this.connectionGater = components.connectionGater
+
+    if (init.discoverRelays != null && init.discoverRelays > 0) {
+      this.discovery = new RelayDiscovery(components)
+      this.discovery.addEventListener('relay:discover', (evt) => {
+        this.reservationStore.addRelay(evt.detail, 'discovered')
+          .catch(err => {
+            log.error('could not add discovered relay %p', evt.detail, err)
+          })
+      })
+    }
+
+    this.reservationStore = new ReservationStore(components, init)
+    this.reservationStore.addEventListener('relay:not-enough-relays', () => {
+      this.discovery?.discover()
+        .catch(err => {
+          log.error('could not discover relays', err)
+        })
+    })
+
+    this.started = false
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    await this.reservationStore.start()
+    await this.discovery?.start()
+
+    await this.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
+      void this.onStop(data).catch(err => {
+        log.error(err)
+      })
+    })
+
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    this.discovery?.stop()
+    await this.reservationStore.stop()
+    await this.registrar.unhandle(RELAY_V2_STOP_CODEC)
+
+    this.started = false
+  }
+
+  get [symbol] (): true {
+    return true
+  }
+
+  get [Symbol.toStringTag] (): 'libp2p/circuit-relay-v2' {
+    return 'libp2p/circuit-relay-v2'
+  }
+
+  /**
+   * Dial a peer over a relay
+   */
+  async dial (ma: Multiaddr, options: AbortOptions = {}): Promise<Connection> {
+    if (ma.protoCodes().filter(code => code === CIRCUIT_PROTO_CODE).length !== 1) {
+      const errMsg = 'Invalid circuit relay address'
+      log.error(errMsg, ma)
+      throw createError(new Error(errMsg), codes.ERR_RELAYED_DIAL)
+    }
+
+    // Check the multiaddr to see if it contains a relay and a destination peer
+    const addrs = ma.toString().split('/p2p-circuit')
+    const relayAddr = multiaddr(addrs[0])
+    const destinationAddr = multiaddr(addrs[addrs.length - 1])
+    const relayId = relayAddr.getPeerId()
+    const destinationId = destinationAddr.getPeerId()
+
+    if (relayId == null || destinationId == null) {
+      const errMsg = 'Circuit relay dial failed as addresses did not have peer id'
+      log.error(errMsg)
+      throw createError(new Error(errMsg), codes.ERR_RELAYED_DIAL)
+    }
+
+    const relayPeer = peerIdFromString(relayId)
+    const destinationPeer = peerIdFromString(destinationId)
+
+    let disconnectOnFailure = false
+    const relayConnections = this.connectionManager.getConnections(relayPeer)
+    let relayConnection = relayConnections[0]
+
+    if (relayConnection == null) {
+      await this.peerStore.addressBook.add(relayPeer, [relayAddr])
+      relayConnection = await this.connectionManager.openConnection(relayPeer, options)
+      disconnectOnFailure = true
+    }
+
+    try {
+      const stream = await relayConnection.newStream([RELAY_V2_HOP_CODEC])
+
+      return await this.connectV2({
+        stream,
+        connection: relayConnection,
+        destinationPeer,
+        destinationAddr,
+        relayAddr,
+        ma,
+        disconnectOnFailure
+      })
+    } catch (err: any) {
+      log.error('Circuit relay dial failed', err)
+      disconnectOnFailure && await relayConnection.close()
+      throw err
+    }
+  }
+
+  async connectV2 (
+    {
+      stream, connection, destinationPeer,
+      destinationAddr, relayAddr, ma,
+      disconnectOnFailure
+    }: ConnectOptions
+  ): Promise<Connection> {
+    try {
+      const pbstr = pbStream(stream)
+      const hopstr = pbstr.pb(HopMessage)
+      hopstr.write({
+        type: HopMessage.Type.CONNECT,
+        peer: {
+          id: destinationPeer.toBytes(),
+          addrs: [multiaddr(destinationAddr).bytes]
+        }
+      })
+
+      const status = await hopstr.read()
+
+      if (status.status !== Status.OK) {
+        throw createError(new Error(`failed to connect via relay with status ${status?.status?.toString() ?? 'undefined'}`), codes.ERR_HOP_REQUEST_FAILED)
+      }
+
+      // TODO: do something with limit and transient connection
+
+      const maConn = streamToMaConnection({
+        stream: pbstr.unwrap(),
+        remoteAddr: ma,
+        localAddr: relayAddr.encapsulate(`/p2p-circuit/p2p/${this.peerId.toString()}`)
+      })
+
+      log('new outbound connection %s', maConn.remoteAddr)
+      return await this.upgrader.upgradeOutbound(maConn)
+    } catch (err) {
+      log.error('Circuit relay dial failed', err)
+      disconnectOnFailure && await connection.close()
+      throw err
+    }
+  }
+
+  /**
+   * Create a listener
+   */
+  createListener (options: CreateListenerOptions): Listener {
+    return createListener({
+      connectionManager: this.connectionManager,
+      relayStore: this.reservationStore
+    })
+  }
+
+  /**
+   * Filter check for all Multiaddrs that this transport can dial on
+   *
+   * @param {Multiaddr[]} multiaddrs
+   * @returns {Multiaddr[]}
+   */
+  filter (multiaddrs: Multiaddr[]): Multiaddr[] {
+    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
+
+    return multiaddrs.filter((ma) => {
+      return mafmt.Circuit.matches(ma)
+    })
+  }
+
+  /**
+   * An incoming STOP request means a remote peer wants to dial us via a relay
+   */
+  async onStop ({ connection, stream }: IncomingStreamData): Promise<void> {
+    const pbstr = pbStream(stream)
+    const request = await pbstr.readPB(StopMessage)
+    log('received circuit v2 stop protocol request from %s', connection.remotePeer)
+
+    if (request?.type === undefined) {
+      return
+    }
+
+    const stopstr = pbstr.pb(StopMessage)
+    log('new circuit relay v2 stop stream from %s', connection.remotePeer)
+
+    // Validate the STOP request has the required input
+    if (request.type !== StopMessage.Type.CONNECT) {
+      log.error('invalid stop connect request via peer %s', connection.remotePeer)
+      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
+      return
+    }
+
+    if (!isValidStop(request)) {
+      log.error('invalid stop connect request via peer %s', connection.remotePeer)
+      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
+      return
+    }
+
+    const remotePeerId = peerIdFromBytes(request.peer.id)
+
+    if ((await this.connectionGater.denyInboundRelayedConnection?.(connection.remotePeer, remotePeerId)) === true) {
+      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      return
+    }
+
+    stopstr.write({ type: StopMessage.Type.STATUS, status: Status.OK })
+
+    const remoteAddr = connection.remoteAddr.encapsulate(`/p2p-circuit/p2p/${remotePeerId.toString()}`)
+    const localAddr = this.addressManager.getAddresses()[0]
+    const maConn = streamToMaConnection({
+      stream: pbstr.unwrap(),
+      remoteAddr,
+      localAddr
+    })
+
+    log('new inbound connection %s', maConn.remoteAddr)
+    await this.upgrader.upgradeInbound(maConn)
+    log('%s connection %s upgraded', 'inbound', maConn.remoteAddr)
+  }
+}
+
+export function circuitRelayTransport (init: CircuitRelayTransportInit = {}): (components: CircuitRelayTransportComponents) => Transport {
+  return (components) => {
+    return new CircuitRelayTransport(components, init)
+  }
+}

package/src/circuit/transport/listener.ts

@@ -0,0 +1,99 @@
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import { multiaddr } from '@multiformats/multiaddr'
+import type { ReservationStore } from './reservation-store'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { PeerMap } from '@libp2p/peer-collections'
+import { logger } from '@libp2p/logger'
+
+const log = logger('libp2p:circuit-relay:transport:listener')
+
+export interface CircuitRelayTransportListenerComponents {
+  connectionManager: ConnectionManager
+  relayStore: ReservationStore
+}
+
+class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> implements Listener {
+  private readonly connectionManager: ConnectionManager
+  private readonly relayStore: ReservationStore
+  private readonly listeningAddrs: PeerMap<Multiaddr>
+
+  constructor (components: CircuitRelayTransportListenerComponents) {
+    super()
+
+    this.connectionManager = components.connectionManager
+    this.relayStore = components.relayStore
+    this.listeningAddrs = new PeerMap()
+
+    // remove listening addrs when a relay is removed
+    this.relayStore.addEventListener('relay:removed', (evt) => {
+      this.#removeRelayPeer(evt.detail)
+    })
+
+    // remove listening addrs when a peer disconnects
+    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+      this.#removeRelayPeer(evt.detail.remotePeer)
+    })
+  }
+
+  async listen (addr: Multiaddr): Promise<void> {
+    log('listen on %s', addr)
+
+    const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
+    const ma = multiaddr(addrString)
+    const relayConn = await this.connectionManager.openConnection(ma)
+
+    if (!this.relayStore.hasReservation(relayConn.remotePeer)) {
+      // addRelay calls transportManager.listen which calls this listen method
+      await this.relayStore.addRelay(relayConn.remotePeer, 'configured')
+      return
+    }
+
+    if (this.listeningAddrs.has(relayConn.remotePeer)) {
+      log('already listening on relay %p', relayConn.remotePeer)
+      return
+    }
+
+    this.listeningAddrs.set(relayConn.remotePeer, addr)
+    this.dispatchEvent(new CustomEvent('listening'))
+  }
+
+  /**
+   * Get fixed up multiaddrs
+   *
+   * NOTE: This method will grab the peers multiaddrs and expand them such that:
+   *
+   * a) If it's an existing /p2p-circuit address for a specific relay i.e.
+   * `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit` this method will expand the
+   * address to `/ip4/0.0.0.0/tcp/0/ipfs/QmRelay/p2p-circuit/ipfs/QmPeer` where
+   * `QmPeer` is this peers id
+   * b) If it's not a /p2p-circuit address, it will encapsulate the address as a /p2p-circuit
+   * addr, such when dialing over a relay with this address, it will create the circuit using
+   * the encapsulated transport address. This is useful when for example, a peer should only
+   * be dialed over TCP rather than any other transport
+   */
+  getAddrs (): Multiaddr[] {
+    return [...this.listeningAddrs.values()]
+  }
+
+  async close (): Promise<void> {
+
+  }
+
+  #removeRelayPeer (peerId: PeerId): void {
+    const had = this.listeningAddrs.has(peerId)
+
+    this.listeningAddrs.delete(peerId)
+
+    if (had) {
+      // Announce listen addresses change
+      this.dispatchEvent(new CustomEvent('close'))
+    }
+  }
+}
+
+export function createListener (options: CircuitRelayTransportListenerComponents): Listener {
+  return new CircuitRelayTransportListener(options)
+}

package/src/circuit/transport/reservation-store.ts

@@ -0,0 +1,249 @@
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { PeerMap } from '@libp2p/peer-collections'
+import PQueue from 'p-queue'
+import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { logger } from '@libp2p/logger'
+import { pbStream } from 'it-pb-stream'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Connection } from '@libp2p/interface-connection'
+import type { Reservation } from '../pb/index.js'
+import { HopMessage, Status } from '../pb/index.js'
+import { getExpiration } from '../utils.js'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { Startable } from '@libp2p/interfaces/dist/src/startable.js'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import { multiaddr } from '@multiformats/multiaddr'
+
+const log = logger('libp2p:circuit-relay:transport:reservation-store')
+
+// allow refreshing a relay reservation if it will expire in the next 10 minutes
+const REFRESH_WINDOW = (60 * 1000) * 10
+
+// try to refresh relay reservations 5 minutes before expiry
+const REFRESH_TIMEOUT = (60 * 1000) * 5
+
+export interface RelayStoreComponents {
+  peerId: PeerId
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  peerStore: PeerStore
+}
+
+export interface RelayStoreInit {
+  /**
+   * Multiple relays may be discovered simultaneously - to prevent listening
+   * on too many relays, this value controls how many to attempt to reserve a
+   * slot on at once. If set to more than one, we may end up listening on
+   * more relays than the `maxReservations` value, but on networks with poor
+   * connectivity the user may wish to attempt to reserve on multiple relays
+   * simultaneously. (default: 1)
+   */
+  reservationConcurrency?: number
+
+  /**
+   * How many discovered relays to allow in the reservation store
+   */
+  discoverRelays?: number
+}
+
+export type RelayType = 'discovered' | 'configured'
+
+interface RelayEntry {
+  timeout: ReturnType<typeof setTimeout>
+  type: RelayType
+  reservation: Reservation
+}
+
+export interface ReservationStoreEvents {
+  'relay:not-enough-relays': CustomEvent
+  'relay:removed': CustomEvent<PeerId>
+}
+
+export class ReservationStore extends EventEmitter<ReservationStoreEvents> implements Startable {
+  private readonly peerId: PeerId
+  private readonly connectionManager: ConnectionManager
+  private readonly transportManager: TransportManager
+  private readonly peerStore: PeerStore
+  private readonly reserveQueue: PQueue
+  private readonly reservations: PeerMap<RelayEntry>
+  private readonly maxDiscoveredRelays: number
+  private started: boolean
+
+  constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
+    super()
+
+    this.peerId = components.peerId
+    this.connectionManager = components.connectionManager
+    this.transportManager = components.transportManager
+    this.peerStore = components.peerStore
+    this.reservations = new PeerMap()
+    this.maxDiscoveredRelays = init?.discoverRelays ?? 0
+    this.started = false
+
+    // ensure we don't listen on multiple relays simultaneously
+    this.reserveQueue = new PQueue({
+      concurrency: init?.reservationConcurrency ?? DEFAULT_RESERVATION_CONCURRENCY
+    })
+
+    // When a peer disconnects, if we had a reservation on that peer
+    // remove the reservation and multiaddr and maybe trigger search
+    // for new relays
+    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+      this.removeRelay(evt.detail.remotePeer)
+    })
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    this.started = true
+  }
+
+  async stop (): Promise<void> {
+    this.reservations.forEach(({ timeout }) => {
+      clearTimeout(timeout)
+    })
+    this.reservations.clear()
+
+    this.started = true
+  }
+
+  /**
+   * If the number of current relays is beneath the configured `maxReservations`
+   * value, and the passed peer id is not our own, and we have a non-relayed connection
+   * to the remote, and the remote peer speaks the hop protocol, try to reserve a slot
+   * on the remote peer
+   */
+  async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
+    log('add relay', this.reserveQueue.size)
+
+    await this.reserveQueue.add(async () => {
+      try {
+        if (this.peerId.equals(peerId)) {
+          log('not trying to use self as relay')
+          return
+        }
+
+        // allow refresh of an existing reservation if it is about to expire
+        const existingReservation = this.reservations.get(peerId)
+
+        if (existingReservation != null) {
+          if (getExpiration(existingReservation.reservation.expire) > REFRESH_WINDOW) {
+            log('already have reservation on relay peer %p and it expires in more than 10 minutes', peerId)
+            return
+          }
+
+          clearTimeout(existingReservation.timeout)
+          this.reservations.delete(peerId)
+        }
+
+        if (type === 'discovered' && [...this.reservations.values()].reduce((acc, curr) => {
+          if (curr.type === 'discovered') {
+            acc++
+          }
+
+          return acc
+        }, 0) >= this.maxDiscoveredRelays) {
+          log('already have enough discovered relays')
+          return
+        }
+
+        const connection = await this.connectionManager.openConnection(peerId)
+
+        if (connection.remoteAddr.protoNames().includes('p2p-circuit')) {
+          log('not creating reservation over relayed connection')
+          return
+        }
+
+        const reservation = await this.#createReservation(connection)
+
+        log('created reservation on relay peer %p', peerId)
+
+        const expiration = getExpiration(reservation.expire)
+
+        const timeout = setTimeout(() => {
+          this.addRelay(peerId, type).catch(err => {
+            log.error('could not refresh reservation to relay %p', peerId, err)
+          })
+        }, Math.max(expiration - REFRESH_TIMEOUT, 0))
+
+        this.reservations.set(peerId, {
+          timeout,
+          reservation,
+          type
+        })
+
+        // ensure we don't close the connection to the relay
+        await this.peerStore.tagPeer(peerId, RELAY_TAG, {
+          value: 1,
+          ttl: expiration
+        })
+
+        await this.transportManager.listen(
+          reservation.addrs.map(ma => {
+            return multiaddr(ma).encapsulate('/p2p-circuit')
+          })
+        )
+      } catch (err) {
+        log.error('could not reserve slot on %p', peerId, err)
+      }
+    })
+  }
+
+  hasReservation (peerId: PeerId): boolean {
+    return this.reservations.has(peerId)
+  }
+
+  async #createReservation (connection: Connection): Promise<Reservation> {
+    log('requesting reservation from %s', connection.remotePeer)
+    const stream = await connection.newStream(RELAY_V2_HOP_CODEC)
+    const pbstr = pbStream(stream)
+    const hopstr = pbstr.pb(HopMessage)
+    hopstr.write({ type: HopMessage.Type.RESERVE })
+
+    let response: HopMessage
+
+    try {
+      response = await hopstr.read()
+    } catch (err: any) {
+      log.error('error parsing reserve message response from %s because', connection.remotePeer, err.message)
+      throw err
+    } finally {
+      stream.close()
+    }
+
+    if (response.status === Status.OK && (response.reservation != null)) {
+      return response.reservation
+    }
+
+    const errMsg = `reservation failed with status ${response.status ?? 'undefined'}`
+    log.error(errMsg)
+
+    throw new Error(errMsg)
+  }
+
+  /**
+   * Remove listen relay
+   */
+  removeRelay (peerId: PeerId): void {
+    const existingReservation = this.reservations.get(peerId)
+
+    if (existingReservation == null) {
+      return
+    }
+
+    log('removing relay %p', peerId)
+
+    clearTimeout(existingReservation.timeout)
+    this.reservations.delete(peerId)
+
+    this.safeDispatchEvent('relay:removed', { detail: peerId })
+
+    if (this.reservations.size < this.maxDiscoveredRelays) {
+      this.dispatchEvent(new CustomEvent('relay:not-enough-relays'))
+    }
+  }
+}