libp2p 0.36.0 → 0.36.1

package/dist/src/index.d.ts

@@ -137,98 +137,6 @@ declare class Libp2p extends EventEmitter {
             enabled: boolean;
         };
         peerStore: {
-            /**
-             * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
-             * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
-             * @typedef {import('libp2p-interfaces/src/transport/types').TransportFactory<any, any>} TransportFactory
-             * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxerFactory} MuxerFactory
-             * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
-             * @typedef {import('libp2p-interfaces/src/peer-discovery/types').PeerDiscoveryFactory} PeerDiscoveryFactory
-             * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
-             * @typedef {import('libp2p-interfaces/src/crypto/types').Crypto} Crypto
-             * @typedef {import('libp2p-interfaces/src/pubsub')} Pubsub
-             * @typedef {import('libp2p-interfaces/src/pubsub').PubsubOptions} PubsubOptions
-             * @typedef {import('interface-datastore').Datastore} Datastore
-             * @typedef {import('./pnet')} Protector
-             * @typedef {import('./types').ConnectionGater} ConnectionGater
-             * @typedef {Object} PersistentPeerStoreOptions
-             * @property {number} [threshold]
-             */
-            /**
-             * @typedef {Object} HandlerProps
-             * @property {Connection} connection
-             * @property {MuxedStream} stream
-             * @property {string} protocol
-             *
-             * @typedef {Object} DhtOptions
-             * @property {boolean} [enabled = false]
-             * @property {number} [kBucketSize = 20]
-             * @property {boolean} [clientMode]
-             * @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors]
-             * @property {import('libp2p-interfaces/src/types').DhtValidators} [validators]
-             *
-             * @typedef {Object} KeychainOptions
-             * @property {Datastore} [datastore]
-             *
-             * @typedef {Object} PeerStoreOptions
-             * @property {boolean} persistence
-             *
-             * @typedef {Object} PubsubLocalOptions
-             * @property {boolean} enabled
-             *
-             * @typedef {Object} MetricsOptions
-             * @property {boolean} enabled
-             *
-             * @typedef {Object} RelayOptions
-             * @property {boolean} [enabled = true]
-             * @property {import('./circuit').RelayAdvertiseOptions} [advertise]
-             * @property {import('./circuit').HopOptions} [hop]
-             * @property {import('./circuit').AutoRelayOptions} [autoRelay]
-             *
-             * @typedef {Object} Libp2pConfig
-             * @property {DhtOptions} [dht] dht module options
-             * @property {import('./nat-manager').NatManagerOptions} [nat]
-             * @property {Record<string, Object|boolean>} [peerDiscovery]
-             * @property {PubsubLocalOptions & PubsubOptions} [pubsub] pubsub module options
-             * @property {RelayOptions} [relay]
-             * @property {Record<string, Object>} [transport] transport options indexed by transport key
-             *
-             * @typedef {Object} Libp2pModules
-             * @property {TransportFactory[]} transport
-             * @property {MuxerFactory[]} streamMuxer
-             * @property {Crypto[]} connEncryption
-             * @property {PeerDiscoveryFactory[]} [peerDiscovery]
-             * @property {PeerRoutingModule[]} [peerRouting]
-             * @property {ContentRoutingModule[]} [contentRouting]
-             * @property {Object} [dht]
-             * @property {{new(...args: any[]): Pubsub}} [pubsub]
-             * @property {Protector} [connProtector]
-             *
-             * @typedef {Object} Libp2pOptions
-             * @property {Libp2pModules} modules libp2p modules to use
-             * @property {import('./address-manager').AddressManagerOptions} [addresses]
-             * @property {import('./connection-manager').ConnectionManagerOptions} [connectionManager]
-             * @property {Partial<import('./types').ConnectionGater>} [connectionGater]
-             * @property {Datastore} [datastore]
-             * @property {import('./dialer').DialerOptions} [dialer]
-             * @property {import('./identify/index').HostProperties} [host] libp2p host
-             * @property {KeychainOptions & import('./keychain/index').KeychainOptions} [keychain]
-             * @property {MetricsOptions & import('./metrics').MetricsOptions} [metrics]
-             * @property {import('./peer-routing').PeerRoutingOptions} [peerRouting]
-             * @property {PeerStoreOptions} [peerStore]
-             * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
-             * @property {Libp2pConfig} [config]
-             *
-             * @typedef {Object} constructorOptions
-             * @property {PeerId} peerId
-             *
-             * @typedef {Object} CreateOptions
-             * @property {PeerId} [peerId]
-             *
-             * @extends {EventEmitter}
-             * @fires Libp2p#error Emitted when an error occurs
-             * @fires Libp2p#peer:discovery Emitted when a peer is discovered
-             */
             persistence: boolean;
             threshold: number;
         };
@@ -369,6 +277,7 @@ declare class Libp2p extends EventEmitter {
      */
     private _onDiscoveryPeer;
     fetchService: FetchService;
+    pingService: PingService;
     /**
      * Starts the libp2p node and all its subsystems
      *
@@ -577,6 +486,7 @@ import IdentifyService = require("./identify");
 import PeerRouting = require("./peer-routing");
 import ContentRouting = require("./content-routing");
 import FetchService = require("./fetch");
+import PingService = require("./ping");
 import { Multiaddr } from "multiaddr";
 type Connection = import("libp2p-interfaces/src/connection/connection");
 type CreateOptions = {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"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"}

package/dist/src/ping/index.d.ts

@@ -1,35 +1,42 @@
-export = ping;
+export = PingService;
 /**
  * @typedef {import('../')} Libp2p
  * @typedef {import('multiaddr').Multiaddr} Multiaddr
  * @typedef {import('peer-id')} PeerId
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
  */
-/**
- * Ping a given peer and wait for its response, getting the operation latency.
- *
- * @param {Libp2p} node
- * @param {PeerId|Multiaddr} peer
- * @returns {Promise<number>}
- */
-declare function ping(node: Libp2p, peer: PeerId | Multiaddr): Promise<number>;
-declare namespace ping {
-    export { mount, unmount, Libp2p, Multiaddr, PeerId, MuxedStream };
+declare class PingService {
+    /**
+     * @param {import('../')} libp2p
+     */
+    static getProtocolStr(libp2p: import('../')): string;
+    /**
+     * @param {Libp2p} libp2p
+     */
+    constructor(libp2p: Libp2p);
+    _libp2p: import("../");
+    /**
+     * A handler to register with Libp2p to process ping messages
+     *
+     * @param {Object} options
+     * @param {MuxedStream} options.stream
+     */
+    handleMessage({ stream }: {
+        stream: MuxedStream;
+    }): any;
+    /**
+     * Ping a given peer and wait for its response, getting the operation latency.
+     *
+     * @param {PeerId|Multiaddr} peer
+     * @returns {Promise<number>}
+     */
+    ping(peer: PeerId | Multiaddr): Promise<number>;
 }
-type Libp2p = import('../');
+declare namespace PingService {
+    export { Libp2p, Multiaddr, PeerId, MuxedStream };
+}
+type MuxedStream = import('libp2p-interfaces/src/stream-muxer/types').MuxedStream;
 type PeerId = import('peer-id');
 type Multiaddr = import('multiaddr').Multiaddr;
-/**
- * Subscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-declare function mount(node: Libp2p): void;
-/**
- * Unsubscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-declare function unmount(node: Libp2p): void;
-type MuxedStream = import('libp2p-interfaces/src/stream-muxer/types').MuxedStream;
+type Libp2p = import('../');
 //# sourceMappingURL=index.d.ts.map

package/dist/src/ping/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ping/index.js"],"names":[],"mappings":";AAiBA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,4BAJW,MAAM,QACN,MAAM,GAAC,SAAS,GACd,QAAQ,MAAM,CAAC,CA2B3B;;;;cAtCY,OAAO,KAAK,CAAC;cAEb,OAAO,SAAS,CAAC;iBADjB,OAAO,WAAW,EAAE,SAAS;AAuC1C;;;;GAIG;AACH,6BAFW,MAAM,QAOhB;AAED;;;;GAIG;AACH,+BAFW,MAAM,QAOhB;mBA3DY,OAAO,0CAA0C,EAAE,WAAW"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ping/index.js"],"names":[],"mappings":";AAiBA;;;;;GAKG;AAEH;IACE;;OAEG;IACH,8BAFW,OAAO,KAAK,CAAC,UAIvB;IAED;;OAEG;IACH,oBAFW,MAAM,EAIhB;IADC,uBAAqB;IAGvB;;;;;OAKG;IACH;QAFgC,MAAM,EAA3B,WAAW;YAIrB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GAAC,SAAS,GACd,QAAQ,MAAM,CAAC,CA2B3B;CACF;;;;mBA5DY,OAAO,0CAA0C,EAAE,WAAW;cAD9D,OAAO,SAAS,CAAC;iBADjB,OAAO,WAAW,EAAE,SAAS;cAD7B,OAAO,KAAK,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.36.0",
+  "version": "0.36.1",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",

package/src/index.js

@@ -29,9 +29,9 @@ const Upgrader = require('./upgrader')
 const PeerStore = require('./peer-store')
 const PubsubAdapter = require('./pubsub-adapter')
 const Registrar = require('./registrar')
-const ping = require('./ping')
 const IdentifyService = require('./identify')
 const FetchService = require('./fetch')
+const PingService = require('./ping')
 const NatManager = require('./nat-manager')
 const { updateSelfPeerRecord } = require('./record/utils')
 
@@ -339,12 +339,10 @@ class Libp2p extends EventEmitter {
     this.peerRouting = new PeerRouting(this)
     this.contentRouting = new ContentRouting(this)
 
-    // Mount default protocols
-    ping.mount(this)
-
     this._onDiscoveryPeer = this._onDiscoveryPeer.bind(this)
 
     this.fetchService = new FetchService(this)
+    this.pingService = new PingService(this)
   }
 
   /**
@@ -382,6 +380,10 @@ class Libp2p extends EventEmitter {
       await this.handle(FetchService.PROTOCOL, this.fetchService.handleMessage)
     }
 
+    if (this.pingService) {
+      await this.handle(PingService.getProtocolStr(this), this.pingService.handleMessage)
+    }
+
     try {
       await this._onStarting()
       await this._onDidStart()
@@ -433,9 +435,9 @@ class Libp2p extends EventEmitter {
       await this.natManager.stop()
       await this.transportManager.close()
 
-      this.unhandle(FetchService.PROTOCOL)
+      await this.unhandle(FetchService.PROTOCOL)
+      await this.unhandle(PingService.getProtocolStr(this))
 
-      ping.unmount(this)
       this.dialer.destroy()
     } catch (/** @type {any} */ err) {
       if (err) {
@@ -609,10 +611,10 @@ class Libp2p extends EventEmitter {
 
     // If received multiaddr, ping it
     if (multiaddrs) {
-      return ping(this, multiaddrs[0])
+      return this.pingService.ping(multiaddrs[0])
     }
 
-    return ping(this, id)
+    return this.pingService.ping(id)
   }
 
   /**

package/src/ping/index.js

@@ -22,64 +22,63 @@ const { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } = require('./constants')
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
  */
 
-/**
- * Ping a given peer and wait for its response, getting the operation latency.
- *
- * @param {Libp2p} node
- * @param {PeerId|Multiaddr} peer
- * @returns {Promise<number>}
- */
-async function ping (node, peer) {
-  const protocol = `/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-  // @ts-ignore multiaddr might not have toB58String
-  log('dialing %s to %s', protocol, peer.toB58String ? peer.toB58String() : peer)
+class PingService {
+  /**
+   * @param {import('../')} libp2p
+   */
+  static getProtocolStr (libp2p) {
+    return `/${libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+  }
 
-  const connection = await node.dial(peer)
-  const { stream } = await connection.newStream(protocol)
+  /**
+   * @param {Libp2p} libp2p
+   */
+  constructor (libp2p) {
+    this._libp2p = libp2p
+  }
 
-  const start = Date.now()
-  const data = crypto.randomBytes(PING_LENGTH)
+  /**
+   * A handler to register with Libp2p to process ping messages
+   *
+   * @param {Object} options
+   * @param {MuxedStream} options.stream
+   */
+  handleMessage ({ stream }) {
+    return pipe(stream, stream)
+  }
 
-  const [result] = await pipe(
-    [data],
-    stream,
-    (/** @type {MuxedStream} */ stream) => take(1, stream),
-    toBuffer,
-    collect
-  )
-  const end = Date.now()
+  /**
+   * Ping a given peer and wait for its response, getting the operation latency.
+   *
+   * @param {PeerId|Multiaddr} peer
+   * @returns {Promise<number>}
+   */
+  async ping (peer) {
+    const protocol = `/${this._libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+    // @ts-ignore multiaddr might not have toB58String
+    log('dialing %s to %s', protocol, peer.toB58String ? peer.toB58String() : peer)
 
-  if (!equals(data, result)) {
-    throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
-  }
+    const connection = await this._libp2p.dial(peer)
+    const { stream } = await connection.newStream(protocol)
 
-  return end - start
-}
+    const start = Date.now()
+    const data = crypto.randomBytes(PING_LENGTH)
 
-/**
- * Subscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-function mount (node) {
-  node.handle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`, ({ stream }) => pipe(stream, stream))
-    .catch(err => {
-      log.error(err)
-    })
-}
+    const [result] = await pipe(
+      [data],
+      stream,
+      (/** @type {MuxedStream} */ stream) => take(1, stream),
+      toBuffer,
+      collect
+    )
+    const end = Date.now()
 
-/**
- * Unsubscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-function unmount (node) {
-  node.unhandle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`)
-    .catch(err => {
-      log.error(err)
-    })
+    if (!equals(data, result)) {
+      throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+    }
+
+    return end - start
+  }
 }
 
-exports = module.exports = ping
-exports.mount = mount
-exports.unmount = unmount
+module.exports = PingService