libp2p 0.41.0 → 0.42.0

package/src/libp2p.ts

@@ -32,7 +32,7 @@ import type { Connection } from '@libp2p/interface-connection'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
 import type { PubSub } from '@libp2p/interface-pubsub'
-import type { Registrar, StreamHandler, StreamHandlerOptions } from '@libp2p/interface-registrar'
+import type { Registrar, StreamHandler, StreamHandlerOptions, Topology } from '@libp2p/interface-registrar'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { Libp2p, Libp2pEvents, Libp2pInit, Libp2pOptions } from './index.js'
@@ -56,7 +56,7 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
   public peerId: PeerId
   public dht: DualDHT
   public pubsub: PubSub
-  public identifyService?: IdentifyService
+  public identifyService: IdentifyService
   public fetchService: FetchService
   public pingService: PingService
   public components: Components
@@ -132,6 +132,14 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     // Create the Connection Manager
     this.connectionManager = this.components.connectionManager = new DefaultConnectionManager(this.components, init.connectionManager)
 
+    // forward connection manager events
+    this.components.connectionManager.addEventListener('peer:disconnect', (event) => {
+      this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: event.detail }))
+    })
+    this.components.connectionManager.addEventListener('peer:connect', (event) => {
+      this.dispatchEvent(new CustomEvent<Connection>('peer:connect', { detail: event.detail }))
+    })
+
     // Create the Registrar
     this.registrar = this.components.registrar = new DefaultRegistrar(this.components)
 
@@ -373,6 +381,10 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     return this.components.addressManager.getAddresses()
   }
 
+  getProtocols (): string[] {
+    return this.components.registrar.getProtocols()
+  }
+
   async hangUp (peer: PeerId | Multiaddr): Promise<void> {
     const { id } = getPeer(peer)
 
@@ -462,6 +474,14 @@ export class Libp2pNode extends EventEmitter<Libp2pEvents> implements Libp2p {
     )
   }
 
+  async register (protocol: string, topology: Topology): Promise<string> {
+    return await this.registrar.register(protocol, topology)
+  }
+
+  unregister (id: string) {
+    this.registrar.unregister(id)
+  }
+
   /**
    * Called whenever peer discovery services emit `peer` events.
    * Known peers may be emitted.

package/src/nat-manager.ts

@@ -149,11 +149,16 @@ export class NatManager implements Startable {
 
       const client = await this._getClient()
       const publicIp = this.externalAddress ?? await client.externalIp()
+      const isPrivate = isPrivateIp(publicIp)
 
-      if (isPrivateIp(publicIp)) {
+      if (isPrivate === true) {
         throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`)
       }
 
+      if (isPrivate == null) {
+        throw new Error(`${publicIp} is not an IP address`)
+      }
+
       const publicPort = highPort()
 
       log(`opening uPnP connection from ${publicIp}:${publicPort} to ${host}:${port}`)

package/src/peer-routing.ts

@@ -50,7 +50,7 @@ export interface RefreshManagerInit {
 }
 
 export interface PeerRoutingInit {
-  routers: PeerRouting[]
+  routers?: PeerRouting[]
   refreshManager?: RefreshManagerInit
 }
 
@@ -69,7 +69,7 @@ export class DefaultPeerRouting implements PeerRouting, Startable {
 
   constructor (components: DefaultPeerRoutingComponents, init: PeerRoutingInit) {
     this.components = components
-    this.routers = init.routers
+    this.routers = init.routers ?? []
     this.refreshManagerInit = init.refreshManager ?? {}
     this.started = false
 

package/src/pnet/README.md

@@ -1,34 +1,41 @@
-js-libp2p-pnet
+js-libp2p-pnet <!-- omit in toc -->
 ==================
 
 > Connection protection management for libp2p leveraging PSK encryption via XSalsa20.
 
 **Note**: git history prior to merging into js-libp2p can be found in the original repository, https://github.com/libp2p/js-libp2p-pnet.
 
-## Table of Contents
+## Table of Contents <!-- omit in toc -->
 
-- [js-libp2p-pnet](#js-libp2p-pnet)
-  - [Table of Contents](#table-of-contents)
-  - [Usage](#usage)
-    - [Examples](#examples)
-    - [Private Shared Keys](#private-shared-keys)
-    - [PSK Generation](#psk-generation)
-      - [From libp2p-pnet](#from-libp2p-pnet)
-      - [From a module using libp2p](#from-a-module-using-libp2p)
-      - [Programmatically](#programmatically)
+- [Usage](#usage)
+- [Examples](#examples)
+- [Private Shared Keys](#private-shared-keys)
+- [PSK Generation](#psk-generation)
+    - [From a module using libp2p](#from-a-module-using-libp2p)
+    - [Programmatically](#programmatically)
 
 ## Usage
 
 ```js
-const Protector from 'libp2p-pnet')
-const protector = new Protector(swarmKeyBuffer)
-const privateConnection = protector.protect(myPublicConnection, (err) => { })
+import { createLibp2p } from 'libp2p'
+import { preSharedKey, generateKey } from 'libp2p/pnet'
+
+// Create a Uint8Array and write the swarm key to it
+const swarmKey = new Uint8Array(95)
+generateKey(swarmKey)
+
+const node = await createLibp2p({
+  // ...other options
+  connectionProtector: preSharedKey({
+    psk: swarmKey
+  })
+})
 ```
 
-### Examples
+## Examples
 [Private Networks with IPFS](../../examples/pnet-ipfs)
 
-### Private Shared Keys
+## Private Shared Keys
 
 Private Shared Keys are expected to be in the following format:
 
@@ -38,33 +45,28 @@ Private Shared Keys are expected to be in the following format:
 dffb7e3135399a8b1612b2aaca1c36a3a8ac2cd0cca51ceeb2ced87d308cac6d
 ```
 
-### PSK Generation
+## PSK Generation
 
 A utility method has been created to generate a key for your private network. You can
 use one of the methods below to generate your key.
 
-#### From libp2p-pnet
-
-If you have libp2p locally, you can run the following from the projects root.
-
-```sh
-node ./src/pnet/key-generator.js > swarm.key
-```
-
 #### From a module using libp2p
 
 If you have a module locally that depends on libp2p, you can run the following from
 that project, assuming the node_modules are installed.
 
-```sh
-node -e "require('libp2p/src/pnet').generate(process.stdout)" > swarm.key
+```console
+node -e "import('libp2p/pnet').then(({ generateKey }) => generateKey(process.stdout))" > swarm.key
 ```
 
 #### Programmatically
 
 ```js
-const writeKey from 'libp2p/src/pnet').generate
+import fs from 'fs'
+import { generateKey } from 'libp2p/pnet'
+
 const swarmKey = new Uint8Array(95)
-writeKey(swarmKey)
+generateKey(swarmKey)
+
 fs.writeFileSync('swarm.key', swarmKey)
 ```

package/src/pnet/index.ts

@@ -1,3 +1,27 @@
+/**
+ * @packageDocumentation
+ *
+ * Connection protection management for libp2p leveraging PSK encryption via XSalsa20.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { preSharedKey, generateKey } from 'libp2p/pnet'
+ *
+ * // Create a Uint8Array and write the swarm key to it
+ * const swarmKey = new Uint8Array(95)
+ * generateKey(swarmKey)
+ *
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   connectionProtector: preSharedKey({
+ *     psk: swarmKey
+ *   })
+ * })
+ * ```
+ */
+
 import { logger } from '@libp2p/logger'
 import { pipe } from 'it-pipe'
 import errCode from 'err-code'

package/src/pnet/key-generator.ts

@@ -5,24 +5,19 @@ import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 /**
  * Generates a PSK that can be used in a libp2p-pnet private network
  *
- * @param {Uint8Array} bytes - An object to write the psk into
+ * @param {Uint8Array | NodeJS.WriteStream} bytes - An object to write the psk into
  * @returns {void}
  */
-export function generateKey (bytes: Uint8Array) {
+export function generateKey (bytes: Uint8Array | NodeJS.WriteStream) {
   const psk = uint8ArrayToString(randomBytes(KEY_LENGTH), 'base16')
   const key = uint8ArrayFromString('/key/swarm/psk/1.0.0/\n/base16/\n' + psk)
 
-  bytes.set(key)
+  if (bytes instanceof Uint8Array) {
+    bytes.set(key)
+  } else {
+    bytes.write(key)
+  }
 }
 
 export const NONCE_LENGTH = 24
 export const KEY_LENGTH = 32
-
-try {
-  if (require.main === module) {
-    // @ts-expect-error
-    generate(process.stdout)
-  }
-} catch (error: any) {
-
-}

package/src/transport-manager.ts

@@ -2,6 +2,7 @@ import { logger } from '@libp2p/logger'
 import pSettle from 'p-settle'
 import { codes } from './errors.js'
 import errCode from 'err-code'
+import { FaultTolerance } from '@libp2p/interface-transport'
 import type { Listener, Transport, TransportManager, TransportManagerEvents, Upgrader } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Connection } from '@libp2p/interface-connection'
@@ -270,18 +271,3 @@ export class DefaultTransportManager extends EventEmitter<TransportManagerEvents
     await Promise.all(tasks)
   }
 }
-
-/**
- * Enum Transport Manager Fault Tolerance values
- */
-export enum FaultTolerance {
-  /**
-   * should be used for failing in any listen circumstance
-   */
-  FATAL_ALL = 0,
-
-  /**
-   * should be used for not failing when not listening
-   */
-  NO_FATAL
-}

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '0.41.0'
+export const version = '0.42.0'
 export const name = 'libp2p'