libp2p 0.42.2-f6f73a21 → 0.43.0

package/src/circuit/circuit/stop.ts

@@ -1,83 +0,0 @@
-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/interface-connection'
-import type { Duplex } from 'it-stream-types'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-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<Uint8ArrayList, Uint8ArrayList | 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 extends AbortOptions {
-  connection: Connection
-  request: CircuitPB
-}
-
-/**
- * Creates a STOP request
- */
-export async function stop (options: StopOptions) {
-  const {
-    connection,
-    request,
-    signal
-  } = options
-
-  const stream = await connection.newStream(RELAY_CODEC, {
-    signal
-  })
-  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

@@ -1,87 +0,0 @@
-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/interface-connection'
-import type { Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
-
-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<Uint8ArrayList | Uint8Array>
-  private readonly decoder: Source<Uint8ArrayList>
-
-  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)
-      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)))
-  }
-
-  /**
-   * 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)
-    })
-  }
-}

package/src/circuit/circuit/utils.ts

@@ -1,44 +0,0 @@
-import { multiaddr } from '@multiformats/multiaddr'
-import { CircuitRelay } from '../pb/index.js'
-import type { StreamHandler } from './stream-handler.js'
-
-/**
- * Write a response
- */
-function writeResponse (streamHandler: StreamHandler, status: CircuitRelay.Status) {
-  streamHandler.write({
-    type: CircuitRelay.Type.STATUS,
-    code: status
-  })
-}
-
-/**
- * Validate incomming HOP/STOP message
- */
-export function validateAddrs (msg: CircuitRelay, streamHandler: StreamHandler) {
-  try {
-    if (msg.dstPeer?.addrs != null) {
-      msg.dstPeer.addrs.forEach((addr) => {
-        return multiaddr(addr)
-      })
-    }
-  } catch (err: any) {
-    writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
-      ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
-      : CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID)
-    throw err
-  }
-
-  try {
-    if (msg.srcPeer?.addrs != null) {
-      msg.srcPeer.addrs.forEach((addr) => {
-        return multiaddr(addr)
-      })
-    }
-  } catch (err: any) {
-    writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
-      ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID
-      : CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID)
-    throw err
-  }
-}

package/src/circuit/listener.ts

@@ -1,83 +0,0 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Listener } from '@libp2p/interface-transport'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
-
-export interface ListenerOptions {
-  peerStore: PeerStore
-  connectionManager: ConnectionManager
-}
-
-export function createListener (options: ListenerOptions): Listener {
-  const listeningAddrs = new Map()
-
-  /**
-   * Add swarm handler and listen for incoming connections
-   */
-  async function listen (addr: Multiaddr): Promise<void> {
-    const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
-    const ma = multiaddr(addrString)
-
-    const relayPeerStr = ma.getPeerId()
-
-    if (relayPeerStr == null) {
-      throw new Error('Could not determine relay peer from multiaddr')
-    }
-
-    const relayPeerId = peerIdFromString(relayPeerStr)
-
-    await options.peerStore.addressBook.add(relayPeerId, [ma])
-
-    const relayConn = await options.connectionManager.openConnection(relayPeerId)
-    const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
-
-    listeningAddrs.set(relayConn.remotePeer.toString(), relayedAddr)
-    listener.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
-   *
-   * @returns {Multiaddr[]}
-   */
-  function getAddrs () {
-    const addrs = []
-    for (const addr of listeningAddrs.values()) {
-      addrs.push(addr)
-    }
-    return addrs
-  }
-
-  const listener: Listener = Object.assign(new EventEmitter(), {
-    close: async () => await Promise.resolve(),
-    listen,
-    getAddrs
-  })
-
-  // Remove listeningAddrs when a peer disconnects
-  options.connectionManager.addEventListener('peer:disconnect', (evt) => {
-    const { detail: connection } = evt
-    const deleted = listeningAddrs.delete(connection.remotePeer.toString())
-
-    if (deleted) {
-      // Announce listen addresses change
-      listener.dispatchEvent(new CustomEvent('close'))
-    }
-  })
-
-  return listener
-}

package/src/circuit/multicodec.ts

@@ -1,2 +0,0 @@
-
-export const RELAY_CODEC = '/libp2p/circuit/relay/0.1.0'

package/src/circuit/transport.ts

@@ -1,278 +0,0 @@
-import { logger } from '@libp2p/logger'
-import errCode from 'err-code'
-import * as mafmt from '@multiformats/mafmt'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
-import { CircuitRelay as CircuitPB } from './pb/index.js'
-import { codes } from '../errors.js'
-import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
-import { RELAY_CODEC } from './multicodec.js'
-import { createListener } from './listener.js'
-import { handleCanHop, handleHop, hop } from './circuit/hop.js'
-import { handleStop } from './circuit/stop.js'
-import { StreamHandler } from './circuit/stream-handler.js'
-import { symbol, Upgrader } from '@libp2p/interface-transport'
-import { peerIdFromString } from '@libp2p/peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Listener, Transport, CreateListenerOptions, ConnectionHandler } from '@libp2p/interface-transport'
-import type { Connection } from '@libp2p/interface-connection'
-import type { RelayConfig } from './index.js'
-import { abortableDuplex } from 'abortable-iterator'
-import { TimeoutController } from 'timeout-abort-controller'
-import { setMaxListeners } from 'events'
-import type { Uint8ArrayList } from 'uint8arraylist'
-import type { Duplex } from 'it-stream-types'
-import type { Startable } from '@libp2p/interfaces/startable'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-
-const log = logger('libp2p:circuit')
-
-export interface CircuitComponents {
-  peerId: PeerId
-  peerStore: PeerStore
-  registrar: Registrar
-  connectionManager: ConnectionManager
-  upgrader: Upgrader
-  addressManager: AddressManager
-}
-
-export class Circuit implements Transport, Startable {
-  private handler?: ConnectionHandler
-  private readonly components: CircuitComponents
-  private readonly _init: RelayConfig
-  private _started: boolean
-
-  constructor (components: CircuitComponents, init: RelayConfig) {
-    this._init = init
-    this.components = components
-    this._started = false
-  }
-
-  isStarted () {
-    return this._started
-  }
-
-  async start (): Promise<void> {
-    if (this._started) {
-      return
-    }
-
-    this._started = true
-
-    await this.components.registrar.handle(RELAY_CODEC, (data) => {
-      void this._onProtocol(data).catch(err => {
-        log.error(err)
-      })
-    }, { ...this._init })
-      .catch(err => {
-        log.error(err)
-      })
-  }
-
-  async stop () {
-    await this.components.registrar.unhandle(RELAY_CODEC)
-  }
-
-  hopEnabled () {
-    return true
-  }
-
-  hopActive () {
-    return true
-  }
-
-  get [symbol] (): true {
-    return true
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'libp2p/circuit-relay-v1'
-  }
-
-  async _onProtocol (data: IncomingStreamData) {
-    const { connection, stream } = data
-    const controller = new TimeoutController(this._init.hop.timeout)
-
-    try {
-      // fails on node < 15.4
-      setMaxListeners?.(Infinity, controller.signal)
-    } catch {}
-
-    try {
-      const source = abortableDuplex(stream, controller.signal)
-      const streamHandler = new StreamHandler({
-        stream: {
-          ...stream,
-          ...source
-        }
-      })
-      const request = await streamHandler.read()
-
-      if (request == null) {
-        log('request was invalid, could not read from stream')
-        streamHandler.write({
-          type: CircuitPB.Type.STATUS,
-          code: CircuitPB.Status.MALFORMED_MESSAGE
-        })
-        streamHandler.close()
-        return
-      }
-
-      let virtualConnection: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array> | undefined
-
-      switch (request.type) {
-        case CircuitPB.Type.CAN_HOP: {
-          log('received CAN_HOP request from %p', connection.remotePeer)
-          await handleCanHop({ circuit: this, connection, streamHandler })
-          break
-        }
-        case CircuitPB.Type.HOP: {
-          log('received HOP request from %p', connection.remotePeer)
-          await handleHop({
-            connection,
-            request,
-            streamHandler,
-            circuit: this,
-            connectionManager: this.components.connectionManager
-          })
-          break
-        }
-        case CircuitPB.Type.STOP: {
-          log('received STOP request from %p', connection.remotePeer)
-          virtualConnection = await handleStop({
-            connection,
-            request,
-            streamHandler
-          })
-          break
-        }
-        default: {
-          log('Request of type %s not supported', request.type)
-          streamHandler.write({
-            type: CircuitPB.Type.STATUS,
-            code: CircuitPB.Status.MALFORMED_MESSAGE
-          })
-          streamHandler.close()
-          return
-        }
-      }
-
-      if (virtualConnection != null) {
-        const remoteAddr = connection.remoteAddr
-          .encapsulate('/p2p-circuit')
-          .encapsulate(multiaddr(request.dstPeer?.addrs[0]))
-        const localAddr = multiaddr(request.srcPeer?.addrs[0])
-        const maConn = streamToMaConnection({
-          stream: virtualConnection,
-          remoteAddr,
-          localAddr
-        })
-        const type = request.type === CircuitPB.Type.HOP ? 'relay' : 'inbound'
-        log('new %s connection %s', type, maConn.remoteAddr)
-
-        const conn = await this.components.upgrader.upgradeInbound(maConn)
-        log('%s connection %s upgraded', type, maConn.remoteAddr)
-
-        if (this.handler != null) {
-          this.handler(conn)
-        }
-      }
-    } finally {
-      controller.clear()
-    }
-  }
-
-  /**
-   * Dial a peer over a relay
-   */
-  async dial (ma: Multiaddr, options: AbortOptions = {}): Promise<Connection> {
-    // 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 errCode(new Error(errMsg), codes.ERR_RELAYED_DIAL)
-    }
-
-    const relayPeer = peerIdFromString(relayId)
-    const destinationPeer = peerIdFromString(destinationId)
-
-    let disconnectOnFailure = false
-    const relayConnections = this.components.connectionManager.getConnections(relayPeer)
-    let relayConnection = relayConnections[0]
-
-    if (relayConnection == null) {
-      await this.components.peerStore.addressBook.add(relayPeer, [relayAddr])
-      relayConnection = await this.components.connectionManager.openConnection(relayPeer, options)
-      disconnectOnFailure = true
-    }
-
-    try {
-      const virtualConnection = await hop({
-        ...options,
-        connection: relayConnection,
-        request: {
-          type: CircuitPB.Type.HOP,
-          srcPeer: {
-            id: this.components.peerId.toBytes(),
-            addrs: this.components.addressManager.getAddresses().map(addr => addr.bytes)
-          },
-          dstPeer: {
-            id: destinationPeer.toBytes(),
-            addrs: [multiaddr(destinationAddr).bytes]
-          }
-        }
-      })
-
-      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.components.peerId.toString()}`)
-      const maConn = streamToMaConnection({
-        stream: virtualConnection,
-        remoteAddr: ma,
-        localAddr
-      })
-      log('new outbound connection %s', maConn.remoteAddr)
-
-      return await this.components.upgrader.upgradeOutbound(maConn)
-    } catch (err: any) {
-      log.error('Circuit relay dial failed', err)
-      disconnectOnFailure && await relayConnection.close()
-      throw err
-    }
-  }
-
-  /**
-   * Create a listener
-   */
-  createListener (options: CreateListenerOptions): Listener {
-    // Called on successful HOP and STOP requests
-    this.handler = options.handler
-
-    return createListener({
-      connectionManager: this.components.connectionManager,
-      peerStore: this.components.peerStore
-    })
-  }
-
-  /**
-   * 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)
-    })
-  }
-}