libp2p 0.36.2 → 0.37.0

package/src/circuit/circuit/hop.js

@@ -1,205 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:circuit:hop'), {
-  error: debug('libp2p:circuit:hop:err')
-})
-const errCode = require('err-code')
-
-const PeerId = require('peer-id')
-const { validateAddrs } = require('./utils')
-const StreamHandler = require('./stream-handler')
-const { CircuitRelay: CircuitPB } = require('../protocol')
-const { pipe } = require('it-pipe')
-const { codes: Errors } = require('../../errors')
-
-const { stop } = require('./stop')
-
-const multicodec = require('./../multicodec')
-
-/**
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {import('../transport')} Transport
- */
-
-/**
- * @typedef {Object} HopRequest
- * @property {Connection} connection
- * @property {ICircuitRelay} request
- * @property {StreamHandler} streamHandler
- * @property {Transport} circuit
- */
-
-/**
- * @param {HopRequest} options
- * @returns {Promise<void>}
- */
-async function handleHop ({
-  connection,
-  request,
-  streamHandler,
-  circuit
-}) {
-  // Ensure hop is enabled
-  if (!circuit._options.hop.enabled) {
-    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 (/** @type {any} */ err) {
-    return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err)
-  }
-
-  if (!request.dstPeer) {
-    log('HOP request received but we do not receive a dstPeer')
-    return
-  }
-
-  // Get the connection to the destination (stop) peer
-  const destinationPeer = new PeerId(request.dstPeer.id)
-
-  const destinationConnection = circuit._connectionManager.get(destinationPeer)
-  if (!destinationConnection && !circuit._options.hop.active) {
-    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 (!destinationConnection) {
-    return
-  }
-
-  // Handle the incoming HOP request by performing a STOP request
-  const stopRequest = {
-    type: CircuitPB.Type.STOP,
-    dstPeer: request.dstPeer,
-    srcPeer: request.srcPeer
-  }
-
-  let destinationStream
-  try {
-    destinationStream = await stop({
-      connection: destinationConnection,
-      request: stopRequest
-    })
-  } catch (/** @type {any} */ err) {
-    return log.error(err)
-  }
-
-  log('hop request from %s is valid', connection.remotePeer.toB58String())
-  streamHandler.write({
-    type: CircuitPB.Type.STATUS,
-    code: CircuitPB.Status.SUCCESS
-  })
-  const sourceStream = streamHandler.rest()
-
-  // Short circuit the two streams to create the relayed connection
-  return pipe(
-    sourceStream,
-    destinationStream,
-    sourceStream
-  )
-}
-
-/**
- * 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.
- *
- * @param {object} options
- * @param {Connection} options.connection - Connection to the relay
- * @param {ICircuitRelay} options.request
- * @returns {Promise<MuxedStream>}
- */
-async function hop ({
-  connection,
-  request
-}) {
-  // Create a new stream to the relay
-  const { stream } = await connection.newStream([multicodec.relay])
-  // Send the HOP request
-  const streamHandler = new StreamHandler({ stream })
-  streamHandler.write(request)
-
-  const response = await streamHandler.read()
-
-  if (!response) {
-    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}`), Errors.ERR_HOP_REQUEST_FAILED)
-}
-
-/**
- * Performs a CAN_HOP request to a relay peer, in order to understand its capabilities.
- *
- * @param {object} options
- * @param {Connection} options.connection - Connection to the relay
- * @returns {Promise<boolean>}
- */
-async function canHop ({
-  connection
-}) {
-  // Create a new stream to the relay
-  const { stream } = await connection.newStream([multicodec.relay])
-  // 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 || response.code !== CircuitPB.Status.SUCCESS) {
-    return false
-  }
-
-  return true
-}
-
-/**
- * Creates an unencoded CAN_HOP response based on the Circuits configuration
- *
- * @param {Object} options
- * @param {Connection} options.connection
- * @param {StreamHandler} options.streamHandler
- * @param {Transport} options.circuit
- * @private
- */
-function handleCanHop ({
-  connection,
-  streamHandler,
-  circuit
-}) {
-  const canHop = circuit._options.hop.enabled
-  log('can hop (%s) request from %s', canHop, connection.remotePeer.toB58String())
-  streamHandler.end({
-    type: CircuitPB.Type.STATUS,
-    code: canHop ? CircuitPB.Status.SUCCESS : CircuitPB.Status.HOP_CANT_SPEAK_RELAY
-  })
-}
-
-module.exports = {
-  handleHop,
-  hop,
-  canHop,
-  handleCanHop
-}

package/src/circuit/circuit/stop.js

@@ -1,81 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:circuit:stop'), {
-  error: debug('libp2p:circuit:stop:err')
-})
-
-const { CircuitRelay: CircuitPB } = require('../protocol')
-const multicodec = require('../multicodec')
-const StreamHandler = require('./stream-handler')
-const { validateAddrs } = require('./utils')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
- */
-
-/**
- * Handles incoming STOP requests
- *
- * @private
- * @param {Object} options
- * @param {Connection} options.connection
- * @param {ICircuitRelay} options.request - The CircuitRelay protobuf request (unencoded)
- * @param {StreamHandler} options.streamHandler
- * @returns {Promise<MuxedStream>|void} Resolves a duplex iterable
- */
-module.exports.handleStop = function handleStop ({
-  connection,
-  request,
-  streamHandler
-}) {
-  // Validate the STOP request has the required input
-  try {
-    validateAddrs(request, streamHandler)
-  } catch (/** @type {any} */ err) {
-    return log.error('invalid stop request via peer %s', connection.remotePeer.toB58String(), err)
-  }
-
-  // The request is valid
-  log('stop request is valid')
-  streamHandler.write({
-    type: CircuitPB.Type.STATUS,
-    code: CircuitPB.Status.SUCCESS
-  })
-  return streamHandler.rest()
-}
-
-/**
- * Creates a STOP request
- *
- * @private
- * @param {Object} options
- * @param {Connection} options.connection
- * @param {ICircuitRelay} options.request - The CircuitRelay protobuf request (unencoded)
- * @returns {Promise<MuxedStream|void>} Resolves a duplex iterable
- */
-module.exports.stop = async function stop ({
-  connection,
-  request
-}) {
-  const { stream } = await connection.newStream([multicodec.relay])
-  log('starting stop request to %s', connection.remotePeer.toB58String())
-  const streamHandler = new StreamHandler({ stream })
-
-  streamHandler.write(request)
-  const response = await streamHandler.read()
-
-  if (!response) {
-    return streamHandler.close()
-  }
-
-  if (response.code === CircuitPB.Status.SUCCESS) {
-    log('stop request to %s was successful', connection.remotePeer.toB58String())
-    return streamHandler.rest()
-  }
-
-  log('stop request failed with code %d', response.code)
-  streamHandler.close()
-}

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

@@ -1,94 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:circuit:stream-handler'), {
-  error: debug('libp2p:circuit:stream-handler:err')
-})
-
-const lp = require('it-length-prefixed')
-// @ts-ignore it-handshake does not export types
-const handshake = require('it-handshake')
-const { CircuitRelay } = require('../protocol')
-
-/**
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
- */
-
-class StreamHandler {
-  /**
-   * Create a stream handler for connection
-   *
-   * @class
-   * @param {object} options
-   * @param {MuxedStream} options.stream - A duplex iterable
-   * @param {number} [options.maxLength = 4096] - max bytes length of message
-   */
-  constructor ({ stream, maxLength = 4096 }) {
-    this.stream = stream
-
-    this.shake = handshake(this.stream)
-    // @ts-ignore options are not optional
-    this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength })
-  }
-
-  /**
-   * Read and decode message
-   *
-   * @async
-   */
-  async read () {
-    const msg = await this.decoder.next()
-    if (msg.value) {
-      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
-   *
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
-   * @returns {void}
-   */
-  write (msg) {
-    log('write message type %s', msg.type)
-    // @ts-ignore lp.encode expects type type 'Buffer | BufferList', not 'Uint8Array'
-    this.shake.write(lp.encode.single(CircuitRelay.encode(msg).finish()))
-  }
-
-  /**
-   * Return the handshake rest stream and invalidate handler
-   *
-   * @returns {*} A duplex iterable
-   */
-  rest () {
-    this.shake.rest()
-    return this.shake.stream
-  }
-
-  /**
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
-   */
-  end (msg) {
-    this.write(msg)
-    this.close()
-  }
-
-  /**
-   * Close the stream
-   *
-   * @returns {void}
-   */
-  close () {
-    log('closing the stream')
-    this.rest().sink([])
-  }
-}
-
-module.exports = StreamHandler

package/src/circuit/constants.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const minute = 60 * 1000
-
-module.exports = {
-  ADVERTISE_BOOT_DELAY: 15 * minute, // Delay before HOP relay service is advertised on the network
-  ADVERTISE_TTL: 30 * minute, // Delay Between HOP relay service advertisements on the network
-  CIRCUIT_PROTO_CODE: 290, // Multicodec code
-  HOP_METADATA_KEY: 'hop_relay', // PeerStore metadaBook key for HOP relay service
-  HOP_METADATA_VALUE: 'true', // PeerStore metadaBook value for HOP relay service
-  RELAY_RENDEZVOUS_NS: '/libp2p/relay' // Relay HOP relay service namespace for discovery
-}

package/src/circuit/index.js

@@ -1,102 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:relay'), {
-  error: debug('libp2p:relay:err')
-})
-const { codes } = require('./../errors')
-const {
-  setDelayedInterval,
-  clearDelayedInterval
-// @ts-ignore set-delayed-interval does not export types
-} = require('set-delayed-interval')
-
-const AutoRelay = require('./auto-relay')
-const { namespaceToCid } = require('./utils')
-const {
-  RELAY_RENDEZVOUS_NS
-} = require('./constants')
-
-/**
- * @typedef {import('../')} Libp2p
- *
- * @typedef {Object} RelayAdvertiseOptions
- * @property {number} [bootDelay = ADVERTISE_BOOT_DELAY]
- * @property {boolean} [enabled = true]
- * @property {number} [ttl = ADVERTISE_TTL]
- *
- * @typedef {Object} HopOptions
- * @property {boolean} [enabled = false]
- * @property {boolean} [active = false]
- *
- * @typedef {Object} AutoRelayOptions
- * @property {number} [maxListeners = 2] - maximum number of relays to listen.
- * @property {boolean} [enabled = false]
- */
-
-class Relay {
-  /**
-   * Creates an instance of Relay.
-   *
-   * @class
-   * @param {Libp2p} libp2p
-   */
-  constructor (libp2p) {
-    this._libp2p = libp2p
-    this._options = {
-      ...libp2p._config.relay
-    }
-
-    // Create autoRelay if enabled
-    this._autoRelay = this._options.autoRelay.enabled && new AutoRelay({ libp2p, ...this._options.autoRelay })
-
-    this._advertiseService = this._advertiseService.bind(this)
-  }
-
-  /**
-   * Start Relay service.
-   *
-   * @returns {void}
-   */
-  start () {
-    // Advertise service if HOP enabled
-    const canHop = this._options.hop.enabled
-
-    if (canHop && this._options.advertise.enabled) {
-      this._timeout = setDelayedInterval(
-        this._advertiseService, this._options.advertise.ttl, this._options.advertise.bootDelay
-      )
-    }
-  }
-
-  /**
-   * Stop Relay service.
-   *
-   * @returns {void}
-   */
-  stop () {
-    clearDelayedInterval(this._timeout)
-  }
-
-  /**
-   * Advertise hop relay service in the network.
-   *
-   * @returns {Promise<void>}
-   */
-  async _advertiseService () {
-    try {
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
-      await this._libp2p.contentRouting.provide(cid)
-    } catch (/** @type {any} */ err) {
-      if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
-        log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
-        // Stop the advertise
-        this.stop()
-      } else {
-        log.error(err)
-      }
-    }
-  }
-}
-
-module.exports = Relay

package/src/circuit/listener.js

@@ -1,75 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
-
-/**
- * @typedef {import('libp2p-interfaces/src/transport/types').Listener} Listener
- */
-
-/**
- * @param {import('../')} libp2p
- * @returns {Listener} a transport listener
- */
-module.exports = (libp2p) => {
-  const listeningAddrs = new Map()
-
-  /**
-   * Add swarm handler and listen for incoming connections
-   *
-   * @param {Multiaddr} addr
-   * @returns {Promise<void>}
-   */
-  async function listen (addr) {
-    const addrString = String(addr).split('/p2p-circuit').find(a => a !== '')
-
-    const relayConn = await libp2p.dial(new Multiaddr(addrString))
-    const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
-
-    listeningAddrs.set(relayConn.remotePeer.toB58String(), relayedAddr)
-    listener.emit('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
-  }
-
-  /** @type Listener */
-  const listener = Object.assign(new EventEmitter(), {
-    close: () => Promise.resolve(),
-    listen,
-    getAddrs
-  })
-
-  // Remove listeningAddrs when a peer disconnects
-  libp2p.connectionManager.on('peer:disconnect', (connection) => {
-    const deleted = listeningAddrs.delete(connection.remotePeer.toB58String())
-
-    if (deleted) {
-      // Announce listen addresses change
-      listener.emit('close')
-    }
-  })
-
-  return listener
-}

package/src/circuit/multicodec.js

@@ -1,5 +0,0 @@
-'use strict'
-
-module.exports = {
-  relay: '/libp2p/circuit/relay/0.1.0'
-}