libp2p 0.36.0 → 0.36.2-1473044

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/protocol/index.d.ts

@@ -1,173 +0,0 @@
-import * as $protobuf from "protobufjs";
-/** Properties of a CircuitRelay. */
-export interface ICircuitRelay {
-
-    /** CircuitRelay type */
-    type?: (CircuitRelay.Type|null);
-
-    /** CircuitRelay srcPeer */
-    srcPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay dstPeer */
-    dstPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay code */
-    code?: (CircuitRelay.Status|null);
-}
-
-/** Represents a CircuitRelay. */
-export class CircuitRelay implements ICircuitRelay {
-
-    /**
-     * Constructs a new CircuitRelay.
-     * @param [p] Properties to set
-     */
-    constructor(p?: ICircuitRelay);
-
-    /** CircuitRelay type. */
-    public type: CircuitRelay.Type;
-
-    /** CircuitRelay srcPeer. */
-    public srcPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay dstPeer. */
-    public dstPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay code. */
-    public code: CircuitRelay.Status;
-
-    /**
-     * Encodes the specified CircuitRelay message. Does not implicitly {@link CircuitRelay.verify|verify} messages.
-     * @param m CircuitRelay message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: ICircuitRelay, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes a CircuitRelay message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns CircuitRelay
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): CircuitRelay;
-
-    /**
-     * Creates a CircuitRelay message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns CircuitRelay
-     */
-    public static fromObject(d: { [k: string]: any }): CircuitRelay;
-
-    /**
-     * Creates a plain object from a CircuitRelay message. Also converts values to other types if specified.
-     * @param m CircuitRelay
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: CircuitRelay, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this CircuitRelay to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-export namespace CircuitRelay {
-
-    /** Status enum. */
-    enum Status {
-        SUCCESS = 100,
-        HOP_SRC_ADDR_TOO_LONG = 220,
-        HOP_DST_ADDR_TOO_LONG = 221,
-        HOP_SRC_MULTIADDR_INVALID = 250,
-        HOP_DST_MULTIADDR_INVALID = 251,
-        HOP_NO_CONN_TO_DST = 260,
-        HOP_CANT_DIAL_DST = 261,
-        HOP_CANT_OPEN_DST_STREAM = 262,
-        HOP_CANT_SPEAK_RELAY = 270,
-        HOP_CANT_RELAY_TO_SELF = 280,
-        STOP_SRC_ADDR_TOO_LONG = 320,
-        STOP_DST_ADDR_TOO_LONG = 321,
-        STOP_SRC_MULTIADDR_INVALID = 350,
-        STOP_DST_MULTIADDR_INVALID = 351,
-        STOP_RELAY_REFUSED = 390,
-        MALFORMED_MESSAGE = 400
-    }
-
-    /** Type enum. */
-    enum Type {
-        HOP = 1,
-        STOP = 2,
-        STATUS = 3,
-        CAN_HOP = 4
-    }
-
-    /** Properties of a Peer. */
-    interface IPeer {
-
-        /** Peer id */
-        id: Uint8Array;
-
-        /** Peer addrs */
-        addrs?: (Uint8Array[]|null);
-    }
-
-    /** Represents a Peer. */
-    class Peer implements IPeer {
-
-        /**
-         * Constructs a new Peer.
-         * @param [p] Properties to set
-         */
-        constructor(p?: CircuitRelay.IPeer);
-
-        /** Peer id. */
-        public id: Uint8Array;
-
-        /** Peer addrs. */
-        public addrs: Uint8Array[];
-
-        /**
-         * Encodes the specified Peer message. Does not implicitly {@link CircuitRelay.Peer.verify|verify} messages.
-         * @param m Peer message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: CircuitRelay.IPeer, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes a Peer message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns Peer
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): CircuitRelay.Peer;
-
-        /**
-         * Creates a Peer message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns Peer
-         */
-        public static fromObject(d: { [k: string]: any }): CircuitRelay.Peer;
-
-        /**
-         * Creates a plain object from a Peer message. Also converts values to other types if specified.
-         * @param m Peer
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: CircuitRelay.Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this Peer to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-}