libp2p 0.42.2 → 0.43.0

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
-  })
-}

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'