libp2p 0.36.1-902f10d → 0.36.2-64bfcee

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/multicodec.js

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

package/src/circuit/transport.js

@@ -1,229 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:circuit'), {
-  error: debug('libp2p:circuit:err')
-})
-
-const errCode = require('err-code')
-const mafmt = require('mafmt')
-const { Multiaddr } = require('multiaddr')
-const PeerId = require('peer-id')
-const { CircuitRelay: CircuitPB } = require('./protocol')
-const { codes } = require('../errors')
-
-const toConnection = require('libp2p-utils/src/stream-to-ma-conn')
-
-const { relay: multicodec } = require('./multicodec')
-const createListener = require('./listener')
-const { handleCanHop, handleHop, hop } = require('./circuit/hop')
-const { handleStop } = require('./circuit/stop')
-const StreamHandler = require('./circuit/stream-handler')
-
-const transportSymbol = Symbol.for('@libp2p/js-libp2p-circuit/circuit')
-
-/**
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- */
-
-class Circuit {
-  /**
-   * Creates an instance of the Circuit Transport.
-   *
-   * @class
-   * @param {object} options
-   * @param {import('../')} options.libp2p
-   * @param {import('../upgrader')} options.upgrader
-   */
-  constructor ({ libp2p, upgrader }) {
-    this._dialer = libp2p.dialer
-    this._registrar = libp2p.registrar
-    this._connectionManager = libp2p.connectionManager
-    this._upgrader = upgrader
-    this._options = libp2p._config.relay
-    this._libp2p = libp2p
-    this.peerId = libp2p.peerId
-
-    this._registrar.handle(multicodec, this._onProtocol.bind(this))
-  }
-
-  /**
-   * @param {Object} props
-   * @param {Connection} props.connection
-   * @param {MuxedStream} props.stream
-   */
-  async _onProtocol ({ connection, stream }) {
-    /** @type {import('./circuit/stream-handler')} */
-    const streamHandler = new StreamHandler({ stream })
-    const request = await streamHandler.read()
-
-    if (!request) {
-      return
-    }
-
-    const circuit = this
-    let virtualConnection
-
-    switch (request.type) {
-      case CircuitPB.Type.CAN_HOP: {
-        log('received CAN_HOP request from %s', connection.remotePeer.toB58String())
-        await handleCanHop({ circuit, connection, streamHandler })
-        break
-      }
-      case CircuitPB.Type.HOP: {
-        log('received HOP request from %s', connection.remotePeer.toB58String())
-        virtualConnection = await handleHop({
-          connection,
-          request,
-          streamHandler,
-          circuit
-        })
-        break
-      }
-      case CircuitPB.Type.STOP: {
-        log('received STOP request from %s', connection.remotePeer.toB58String())
-        virtualConnection = await handleStop({
-          connection,
-          request,
-          streamHandler
-        })
-        break
-      }
-      default: {
-        log('Request of type %s not supported', request.type)
-      }
-    }
-
-    if (virtualConnection) {
-      // @ts-ignore dst peer will not be undefined
-      const remoteAddr = new Multiaddr(request.dstPeer.addrs[0])
-      // @ts-ignore src peer will not be undefined
-      const localAddr = new Multiaddr(request.srcPeer.addrs[0])
-      const maConn = toConnection({
-        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._upgrader.upgradeInbound(maConn)
-      log('%s connection %s upgraded', type, maConn.remoteAddr)
-      this.handler && this.handler(conn)
-    }
-  }
-
-  /**
-   * Dial a peer over a relay
-   *
-   * @param {Multiaddr} ma - the multiaddr of the peer to dial
-   * @param {Object} options - dial options
-   * @param {AbortSignal} [options.signal] - An optional abort signal
-   * @returns {Promise<Connection>} - the connection
-   */
-  async dial (ma, options) {
-    // Check the multiaddr to see if it contains a relay and a destination peer
-    const addrs = ma.toString().split('/p2p-circuit')
-    const relayAddr = new Multiaddr(addrs[0])
-    const destinationAddr = new Multiaddr(addrs[addrs.length - 1])
-    const relayId = relayAddr.getPeerId()
-    const destinationId = destinationAddr.getPeerId()
-
-    if (!relayId || !destinationId) {
-      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 = PeerId.createFromB58String(relayId)
-    const destinationPeer = PeerId.createFromB58String(destinationId)
-
-    let disconnectOnFailure = false
-    let relayConnection = this._connectionManager.get(relayPeer)
-    if (!relayConnection) {
-      relayConnection = await this._dialer.connectToPeer(relayAddr, options)
-      disconnectOnFailure = true
-    }
-
-    try {
-      const virtualConnection = await hop({
-        connection: relayConnection,
-        request: {
-          type: CircuitPB.Type.HOP,
-          srcPeer: {
-            id: this.peerId.toBytes(),
-            addrs: this._libp2p.multiaddrs.map(addr => addr.bytes)
-          },
-          dstPeer: {
-            id: destinationPeer.toBytes(),
-            addrs: [new Multiaddr(destinationAddr).bytes]
-          }
-        }
-      })
-
-      const localAddr = relayAddr.encapsulate(`/p2p-circuit/p2p/${this.peerId.toB58String()}`)
-      const maConn = toConnection({
-        stream: virtualConnection,
-        remoteAddr: ma,
-        localAddr
-      })
-      log('new outbound connection %s', maConn.remoteAddr)
-
-      return this._upgrader.upgradeOutbound(maConn)
-    } catch (/** @type {any} */ err) {
-      log.error('Circuit relay dial failed', err)
-      disconnectOnFailure && await relayConnection.close()
-      throw err
-    }
-  }
-
-  /**
-   * Create a listener
-   *
-   * @param {any} options
-   * @param {Function} handler
-   * @returns {import('libp2p-interfaces/src/transport/types').Listener}
-   */
-  createListener (options, handler) {
-    if (typeof options === 'function') {
-      handler = options
-      options = {}
-    }
-
-    // Called on successful HOP and STOP requests
-    this.handler = handler
-
-    return createListener(this._libp2p)
-  }
-
-  /**
-   * Filter check for all Multiaddrs that this transport can dial on
-   *
-   * @param {Multiaddr[]} multiaddrs
-   * @returns {Multiaddr[]}
-   */
-  filter (multiaddrs) {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
-
-    return multiaddrs.filter((ma) => {
-      return mafmt.Circuit.matches(ma)
-    })
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'Circuit'
-  }
-
-  /**
-   * Checks if the given value is a Transport instance.
-   *
-   * @param {any} other
-   * @returns {other is Transport}
-   */
-  static isTransport (other) {
-    return Boolean(other && other[transportSymbol])
-  }
-}
-
-module.exports = Circuit

package/src/circuit/utils.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { CID } = require('multiformats/cid')
-const { sha256 } = require('multiformats/hashes/sha2')
-
-/**
- * Convert a namespace string into a cid.
- *
- * @param {string} namespace
- * @returns {Promise<CID>}
- */
-module.exports.namespaceToCid = async (namespace) => {
-  const bytes = new TextEncoder().encode(namespace)
-  const hash = await sha256.digest(bytes)
-
-  return CID.createV0(hash)
-}

package/src/config.js

@@ -1,114 +0,0 @@
-'use strict'
-
-const mergeOptions = require('merge-options')
-// @ts-ignore no types in multiaddr path
-const { dnsaddrResolver } = require('multiaddr/src/resolvers')
-
-const Constants = require('./constants')
-const { AGENT_VERSION } = require('./identify/consts')
-const RelayConstants = require('./circuit/constants')
-
-const { publicAddressesFirst } = require('libp2p-utils/src/address-sort')
-const { FaultTolerance } = require('./transport-manager')
-
-/**
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('./types').ConnectionGater} ConnectionGater
- * @typedef {import('.').Libp2pOptions} Libp2pOptions
- * @typedef {import('.').constructorOptions} constructorOptions
- */
-
-const DefaultConfig = {
-  addresses: {
-    listen: [],
-    announce: [],
-    noAnnounce: [],
-    announceFilter: (/** @type {Multiaddr[]} */ multiaddrs) => multiaddrs
-  },
-  connectionManager: {
-    minConnections: 25
-  },
-  connectionGater: /** @type {ConnectionGater} */ {},
-  transportManager: {
-    faultTolerance: FaultTolerance.FATAL_ALL
-  },
-  dialer: {
-    maxParallelDials: Constants.MAX_PARALLEL_DIALS,
-    maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
-    dialTimeout: Constants.DIAL_TIMEOUT,
-    resolvers: {
-      dnsaddr: dnsaddrResolver
-    },
-    addressSorter: publicAddressesFirst
-  },
-  host: {
-    agentVersion: AGENT_VERSION
-  },
-  metrics: {
-    enabled: false
-  },
-  peerStore: {
-    persistence: false,
-    threshold: 5
-  },
-  peerRouting: {
-    refreshManager: {
-      enabled: true,
-      interval: 6e5,
-      bootDelay: 10e3
-    }
-  },
-  config: {
-    protocolPrefix: 'ipfs',
-    dht: {
-      enabled: false,
-      kBucketSize: 20
-    },
-    nat: {
-      enabled: true,
-      ttl: 7200,
-      keepAlive: true,
-      gateway: null,
-      externalIp: null,
-      pmp: {
-        enabled: false
-      }
-    },
-    peerDiscovery: {
-      autoDial: true
-    },
-    pubsub: {
-      enabled: true
-    },
-    relay: {
-      enabled: true,
-      advertise: {
-        bootDelay: RelayConstants.ADVERTISE_BOOT_DELAY,
-        enabled: false,
-        ttl: RelayConstants.ADVERTISE_TTL
-      },
-      hop: {
-        enabled: false,
-        active: false
-      },
-      autoRelay: {
-        enabled: false,
-        maxListeners: 2
-      }
-    },
-    transport: {}
-  }
-}
-
-/**
- * @param {Libp2pOptions} opts
- * @returns {DefaultConfig & Libp2pOptions & constructorOptions}
- */
-module.exports.validate = (opts) => {
-  /** @type {DefaultConfig & Libp2pOptions & constructorOptions} */
-  const resultingOptions = mergeOptions(DefaultConfig, opts)
-
-  if (resultingOptions.modules.transport.length < 1) throw new Error("'options.modules.transport' must contain at least 1 transport")
-
-  return resultingOptions
-}