libp2p 0.36.0 → 0.36.2-199395d

package/dist/src/types.d.ts

@@ -1,90 +0,0 @@
-import type PeerId from 'peer-id';
-import type { Multiaddr } from 'multiaddr';
-import type { MultiaddrConnection } from 'libp2p-interfaces/src/transport/types';
-export interface ConnectionGater {
-    /**
-     * denyDialMultiaddr tests whether we're permitted to Dial the
-     * specified peer.
-     *
-     * This is called by the dialer.connectToPeer implementation before
-     * dialling a peer.
-     *
-     * Return true to prevent dialing the passed peer.
-     */
-    denyDialPeer: (peerId: PeerId) => Promise<boolean>;
-    /**
-     * denyDialMultiaddr tests whether we're permitted to dial the specified
-     * multiaddr for the given peer.
-     *
-     * This is called by the dialer.connectToPeer implementation after it has
-     * resolved the peer's addrs, and prior to dialling each.
-     *
-     * Return true to prevent dialing the passed peer on the passed multiaddr.
-     */
-    denyDialMultiaddr: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
-    /**
-     * denyInboundConnection tests whether an incipient inbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has accepted a connection from its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyInboundConnection: (maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundConnection tests whether an incipient outbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has created a connection with its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyOutboundConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyInboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyInboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyOutboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyInboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyInboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * denyOutboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyOutboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>;
-    /**
-     * Used by the address book to filter passed addresses.
-     *
-     * Return true to allow storing the passed multiaddr for the passed peer.
-     */
-    filterMultiaddrForPeer: (peer: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,SAAS,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAA;AAEhF,MAAM,WAAW,eAAe;IAC9B;;;;;;;;OAQG;IACH,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAElD;;;;;;;;OAQG;IACH,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAE7E;;;;;;;OAOG;IACH,qBAAqB,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAExE;;;;;;;OAOG;IACH,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEzF;;;;;;;;;OASG;IACH,8BAA8B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEjG;;;;;;;;;OASG;IACH,+BAA+B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAElG;;;;;;;OAOG;IACH,6BAA6B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEhG;;;;;;;OAOG;IACH,8BAA8B,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAEjG;;;;OAIG;IACH,sBAAsB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACjF"}

package/src/address-manager/index.js

@@ -1,96 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
-const PeerId = require('peer-id')
-
-/**
- * @typedef {Object} AddressManagerOptions
- * @property {string[]} [listen = []] - list of multiaddrs string representation to listen.
- * @property {string[]} [announce = []] - list of multiaddrs string representation to announce.
- */
-
-/**
- * @fires AddressManager#change:addresses Emitted when a addresses change.
- */
-class AddressManager extends EventEmitter {
-  /**
-   * Responsible for managing the peer addresses.
-   * Peers can specify their listen and announce addresses.
-   * The listen addresses will be used by the libp2p transports to listen for new connections,
-   * while the announce addresses will be used for the peer addresses' to other peers in the network.
-   *
-   * @class
-   * @param {PeerId} peerId - The Peer ID of the node
-   * @param {object} [options]
-   * @param {Array<string>} [options.listen = []] - list of multiaddrs string representation to listen.
-   * @param {Array<string>} [options.announce = []] - list of multiaddrs string representation to announce.
-   */
-  constructor (peerId, { listen = [], announce = [] } = {}) {
-    super()
-
-    this.peerId = peerId
-    this.listen = new Set(listen.map(ma => ma.toString()))
-    this.announce = new Set(announce.map(ma => ma.toString()))
-    this.observed = new Set()
-  }
-
-  /**
-   * Get peer listen multiaddrs.
-   *
-   * @returns {Multiaddr[]}
-   */
-  getListenAddrs () {
-    return Array.from(this.listen).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Get peer announcing multiaddrs.
-   *
-   * @returns {Multiaddr[]}
-   */
-  getAnnounceAddrs () {
-    return Array.from(this.announce).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Get observed multiaddrs.
-   *
-   * @returns {Array<Multiaddr>}
-   */
-  getObservedAddrs () {
-    return Array.from(this.observed).map((a) => new Multiaddr(a))
-  }
-
-  /**
-   * Add peer observed addresses
-   *
-   * @param {string | Multiaddr} addr
-   */
-  addObservedAddr (addr) {
-    let ma = new Multiaddr(addr)
-    const remotePeer = ma.getPeerId()
-
-    // strip our peer id if it has been passed
-    if (remotePeer) {
-      const remotePeerId = PeerId.createFromB58String(remotePeer)
-
-      // use same encoding for comparison
-      if (remotePeerId.equals(this.peerId)) {
-        ma = ma.decapsulate(new Multiaddr(`/p2p/${this.peerId}`))
-      }
-    }
-
-    const addrString = ma.toString()
-
-    // do not trigger the change:addresses event if we already know about this address
-    if (this.observed.has(addrString)) {
-      return
-    }
-
-    this.observed.add(addrString)
-    this.emit('change:addresses')
-  }
-}
-
-module.exports = AddressManager

package/src/circuit/auto-relay.js

@@ -1,302 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:auto-relay'), {
-  error: debug('libp2p:auto-relay:err')
-})
-
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { Multiaddr } = require('multiaddr')
-const all = require('it-all')
-
-const { relay: multicodec } = require('./multicodec')
-const { canHop } = require('./circuit/hop')
-const { namespaceToCid } = require('./utils')
-const {
-  CIRCUIT_PROTO_CODE,
-  HOP_METADATA_KEY,
-  HOP_METADATA_VALUE,
-  RELAY_RENDEZVOUS_NS
-} = require('./constants')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('../peer-store/types').Address} Address
- * @typedef {import('peer-id')} PeerId
- */
-
-/**
- * @typedef {Object} AutoRelayProperties
- * @property {import('../')} libp2p
- *
- * @typedef {Object} AutoRelayOptions
- * @property {number} [maxListeners = 1] - maximum number of relays to listen.
- * @property {(error: Error, msg?: string) => {}} [onError]
- */
-
-class AutoRelay {
-  /**
-   * Creates an instance of AutoRelay.
-   *
-   * @class
-   * @param {AutoRelayProperties & AutoRelayOptions} props
-   */
-  constructor ({ libp2p, maxListeners = 1, onError }) {
-    this._libp2p = libp2p
-    this._peerId = libp2p.peerId
-    this._peerStore = libp2p.peerStore
-    this._connectionManager = libp2p.connectionManager
-    this._transportManager = libp2p.transportManager
-    this._addressSorter = libp2p.dialer.addressSorter
-
-    this.maxListeners = maxListeners
-
-    /**
-     * @type {Set<string>}
-     */
-    this._listenRelays = new Set()
-
-    this._onProtocolChange = this._onProtocolChange.bind(this)
-    this._onPeerDisconnected = this._onPeerDisconnected.bind(this)
-
-    this._peerStore.on('change:protocols', this._onProtocolChange)
-    this._connectionManager.on('peer:disconnect', this._onPeerDisconnected)
-
-    /**
-     * @param {Error} error
-     * @param {string} [msg]
-     */
-    this._onError = (error, msg) => {
-      log.error(msg || error)
-      onError && onError(error, msg)
-    }
-  }
-
-  /**
-   * 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.
-   *
-   * @param {Object} props
-   * @param {PeerId} props.peerId
-   * @param {string[]} props.protocols
-   * @returns {Promise<void>}
-   */
-  async _onProtocolChange ({ peerId, protocols }) {
-    const id = peerId.toB58String()
-
-    // Check if it has the protocol
-    const hasProtocol = protocols.find(protocol => protocol === multicodec)
-
-    // If no protocol, check if we were keeping the peer before as a listenRelay
-    if (!hasProtocol && this._listenRelays.has(id)) {
-      await this._removeListenRelay(id)
-      return
-    } else if (!hasProtocol || this._listenRelays.has(id)) {
-      return
-    }
-
-    // If protocol, check if can hop, store info in the metadataBook and listen on it
-    try {
-      const connection = this._connectionManager.get(peerId)
-      if (!connection) {
-        return
-      }
-
-      // 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._peerStore.metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
-        await this._addListenRelay(connection, id)
-      }
-    } catch (/** @type {any} */ err) {
-      this._onError(err)
-    }
-  }
-
-  /**
-   * Peer disconnects.
-   *
-   * @param {Connection} connection - connection to the peer
-   */
-  _onPeerDisconnected (connection) {
-    const peerId = connection.remotePeer
-    const id = peerId.toB58String()
-
-    // 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.
-   *
-   * @private
-   * @param {Connection} connection - connection to the peer
-   * @param {string} id - peer identifier string
-   * @returns {Promise<void>}
-   */
-  async _addListenRelay (connection, id) {
-    try {
-      // Check if already listening on enough relays
-      if (this._listenRelays.size >= this.maxListeners) {
-        return
-      }
-
-      // Get peer known addresses and sort them per public addresses first
-      const remoteAddrs = await this._peerStore.addressBook.getMultiaddrsForPeer(
-        connection.remotePeer, this._addressSorter
-      )
-
-      // Attempt to listen on relay
-      const result = await Promise.all(
-        remoteAddrs.map(async addr => {
-          try {
-            // Announce multiaddrs will update on listen success by TransportManager event being triggered
-            await this._transportManager.listen([new Multiaddr(`${addr.toString()}/p2p-circuit`)])
-            return true
-          } catch (/** @type {any} */ err) {
-            this._onError(err)
-          }
-
-          return false
-        })
-      )
-
-      if (result.includes(true)) {
-        this._listenRelays.add(id)
-      }
-    } catch (/** @type {any} */ err) {
-      this._onError(err)
-      this._listenRelays.delete(id)
-    }
-  }
-
-  /**
-   * Remove listen relay.
-   *
-   * @private
-   * @param {string} id - peer identifier string.
-   */
-  async _removeListenRelay (id) {
-    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.
-   *
-   * @param {string[]} [peersToIgnore]
-   */
-  async _listenOnAvailableHopRelays (peersToIgnore = []) {
-    // 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 all(this._peerStore.getPeers())
-
-    // Check if we have known hop peers to use and attempt to listen on the already connected
-    for await (const { id, metadata } of peers) {
-      const idStr = id.toB58String()
-
-      // 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 || uint8ArrayToString(supportsHop) !== HOP_METADATA_VALUE) {
-        continue
-      }
-
-      const connection = this._connectionManager.get(id)
-
-      // If not connected, store for possible later use.
-      if (!connection) {
-        knownHopsToDial.push(id)
-        continue
-      }
-
-      await this._addListenRelay(connection, 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._libp2p.contentRouting.findProviders(cid)) {
-        if (!provider.multiaddrs.length) {
-          continue
-        }
-
-        const peerId = provider.id
-        await this._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 (/** @type {any} */ err) {
-      this._onError(err)
-    }
-  }
-
-  /**
-   * @param {PeerId} peerId
-   */
-  async _tryToListenOnRelay (peerId) {
-    try {
-      const connection = await this._libp2p.dial(peerId)
-      await this._addListenRelay(connection, peerId.toB58String())
-    } catch (/** @type {any} */ err) {
-      this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
-    }
-  }
-}
-
-module.exports = AutoRelay

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