libp2p 0.36.2 → 0.37.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
-}

package/src/connection-manager/auto-dialler.js

@@ -1,132 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const mergeOptions = require('merge-options')
-// @ts-ignore retimer does not have types
-const retimer = require('retimer')
-const all = require('it-all')
-const { pipe } = require('it-pipe')
-const filter = require('it-filter')
-const sort = require('it-sort')
-
-const log = Object.assign(debug('libp2p:connection-manager:auto-dialler'), {
-  error: debug('libp2p:connection-manager:auto-dialler:err')
-})
-
-const defaultOptions = {
-  enabled: true,
-  minConnections: 0,
-  autoDialInterval: 10000
-}
-
-/**
- * @typedef {import('../index')} Libp2p
- * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- */
-
-/**
- * @typedef {Object} AutoDiallerOptions
- * @property {boolean} [enabled = true] - Should preemptively guarantee connections are above the low watermark
- * @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning
- * @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
- */
-
-class AutoDialler {
-  /**
-   * Proactively tries to connect to known peers stored in the PeerStore.
-   * It will keep the number of connections below the upper limit and sort
-   * the peers to connect based on wether we know their keys and protocols.
-   *
-   * @class
-   * @param {Libp2p} libp2p
-   * @param {AutoDiallerOptions} options
-   */
-  constructor (libp2p, options = {}) {
-    this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
-    this._libp2p = libp2p
-    this._running = false
-    this._autoDialTimeout = null
-    this._autoDial = this._autoDial.bind(this)
-
-    log('options: %j', this._options)
-  }
-
-  /**
-   * Starts the auto dialer
-   */
-  async start () {
-    if (!this._options.enabled) {
-      log('not enabled')
-      return
-    }
-
-    this._running = true
-    this._autoDial().catch(err => {
-      log.error('could start autodial', err)
-    })
-    log('started')
-  }
-
-  /**
-   * Stops the auto dialler
-   */
-  async stop () {
-    if (!this._options.enabled) {
-      log('not enabled')
-      return
-    }
-
-    this._running = false
-    this._autoDialTimeout && this._autoDialTimeout.clear()
-    log('stopped')
-  }
-
-  async _autoDial () {
-    const minConnections = this._options.minConnections
-
-    // Already has enough connections
-    if (this._libp2p.connections.size >= minConnections) {
-      this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-      return
-    }
-
-    // Sort peers on whether we know protocols of public keys for them
-    // TODO: assuming the `peerStore.getPeers()` order is stable this will mean
-    // we keep trying to connect to the same peers?
-    const peers = await pipe(
-      this._libp2p.peerStore.getPeers(),
-      (source) => filter(source, (peer) => !peer.id.equals(this._libp2p.peerId)),
-      (source) => sort(source, (a, b) => {
-        if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
-          return 1
-        } else if (b.id.pubKey && !a.id.pubKey) {
-          return 1
-        }
-        return -1
-      }),
-      (source) => all(source)
-    )
-
-    for (let i = 0; this._running && i < peers.length && this._libp2p.connections.size < minConnections; i++) {
-      const peer = peers[i]
-
-      if (!this._libp2p.connectionManager.get(peer.id)) {
-        log('connecting to a peerStore stored peer %s', peer.id.toB58String())
-        try {
-          await this._libp2p.dialer.connectToPeer(peer.id)
-        } catch (/** @type {any} */ err) {
-          log.error('could not connect to peerStore stored peer', err)
-        }
-      }
-    }
-
-    // Connection Manager was stopped
-    if (!this._running) {
-      return
-    }
-
-    this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-  }
-}
-
-module.exports = AutoDialler