libp2p 0.36.0 → 0.36.2-199395d

package/src/circuit/circuit/{utils.js → utils.ts}

@@ -1,20 +1,11 @@
-'use strict'
-
-const { Multiaddr } = require('multiaddr')
-const { CircuitRelay } = require('../protocol')
-
-/**
- * @typedef {import('./stream-handler')} StreamHandler
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
- */
+import { Multiaddr } from '@multiformats/multiaddr'
+import { CircuitRelay, ICircuitRelay } from '../pb/index.js'
+import type { StreamHandler } from './stream-handler.js'
 
 /**
  * Write a response
- *
- * @param {StreamHandler} streamHandler
- * @param {import('../protocol').CircuitRelay.Status} status
  */
-function writeResponse (streamHandler, status) {
+function writeResponse (streamHandler: StreamHandler, status: CircuitRelay.Status) {
   streamHandler.write({
     type: CircuitRelay.Type.STATUS,
     code: status
@@ -23,18 +14,15 @@ function writeResponse (streamHandler, status) {
 
 /**
  * Validate incomming HOP/STOP message
- *
- * @param {ICircuitRelay} msg - A CircuitRelay unencoded protobuf message
- * @param {StreamHandler} streamHandler
  */
-function validateAddrs (msg, streamHandler) {
+export function validateAddrs (msg: ICircuitRelay, streamHandler: StreamHandler) {
   try {
-    if (msg.dstPeer && msg.dstPeer.addrs) {
+    if (msg.dstPeer?.addrs != null) {
       msg.dstPeer.addrs.forEach((addr) => {
         return new Multiaddr(addr)
       })
     }
-  } catch (/** @type {any} */ err) {
+  } catch (err: any) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID)
@@ -42,19 +30,15 @@ function validateAddrs (msg, streamHandler) {
   }
 
   try {
-    if (msg.srcPeer && msg.srcPeer.addrs) {
+    if (msg.srcPeer?.addrs != null) {
       msg.srcPeer.addrs.forEach((addr) => {
         return new Multiaddr(addr)
       })
     }
-  } catch (/** @type {any} */ err) {
+  } catch (err: any) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID)
     throw err
   }
 }
-
-module.exports = {
-  validateAddrs
-}

package/src/circuit/constants.ts

@@ -0,0 +1,31 @@
+const minute = 60 * 1000
+
+/**
+ * Delay before HOP relay service is advertised on the network
+ */
+export const ADVERTISE_BOOT_DELAY = 15 * minute
+
+/**
+ * Delay Between HOP relay service advertisements on the network
+ */
+export const ADVERTISE_TTL = 30 * minute
+
+/**
+ * Multicodec code
+ */
+export const CIRCUIT_PROTO_CODE = 290
+
+/**
+ * PeerStore metadaBook key for HOP relay service
+ */
+export const HOP_METADATA_KEY = 'hop_relay'
+
+/**
+ * PeerStore metadaBook value for HOP relay service
+ */
+export const HOP_METADATA_VALUE = 'true'
+
+/**
+ * Relay HOP relay service namespace for discovery
+ */
+export const RELAY_RENDEZVOUS_NS = '/libp2p/relay'

package/src/circuit/index.ts

@@ -0,0 +1,120 @@
+import { logger } from '@libp2p/logger'
+import { codes } from '../errors.js'
+import {
+  setDelayedInterval,
+  clearDelayedInterval
+// @ts-expect-error set-delayed-interval does not export types
+} from 'set-delayed-interval'
+import { AutoRelay } from './auto-relay.js'
+import { namespaceToCid } from './utils.js'
+import {
+  RELAY_RENDEZVOUS_NS
+} from './constants.js'
+import type { AddressSorter } from '@libp2p/interfaces/peer-store'
+import type { Startable } from '@libp2p/interfaces'
+import type { Components } from '@libp2p/interfaces/components'
+
+const log = logger('libp2p:relay')
+
+export interface RelayAdvertiseConfig {
+  bootDelay?: number
+  enabled?: boolean
+  ttl?: number
+}
+
+export interface HopConfig {
+  enabled?: boolean
+  active?: boolean
+}
+
+export interface AutoRelayConfig {
+  enabled?: boolean
+
+  /**
+   * maximum number of relays to listen
+   */
+  maxListeners: number
+}
+
+export interface RelayInit {
+  addressSorter?: AddressSorter
+  maxListeners?: number
+  onError?: (error: Error, msg?: string) => void
+  hop: HopConfig
+  advertise: RelayAdvertiseConfig
+  autoRelay: AutoRelayConfig
+}
+
+export class Relay implements Startable {
+  private readonly components: Components
+  private readonly init: RelayInit
+  // @ts-expect-error this field isn't used anywhere?
+  private readonly autoRelay?: AutoRelay
+  private timeout?: any
+  private started: boolean
+
+  /**
+   * Creates an instance of Relay
+   */
+  constructor (components: Components, init: RelayInit) {
+    this.components = components
+    // Create autoRelay if enabled
+    this.autoRelay = init.autoRelay?.enabled !== false
+      ? new AutoRelay(components, {
+        addressSorter: init.addressSorter,
+        ...init.autoRelay
+      })
+      : undefined
+
+    this.started = false
+    this.init = init
+    this._advertiseService = this._advertiseService.bind(this)
+  }
+
+  isStarted () {
+    return this.started
+  }
+
+  /**
+   * Start Relay service
+   */
+  async start () {
+    // Advertise service if HOP enabled
+    if (this.init.hop.enabled !== false && this.init.advertise.enabled !== false) {
+      this.timeout = setDelayedInterval(
+        this._advertiseService, this.init.advertise.ttl, this.init.advertise.bootDelay
+      )
+    }
+
+    this.started = true
+  }
+
+  /**
+   * Stop Relay service
+   */
+  async stop () {
+    if (this.timeout != null) {
+      clearDelayedInterval(this.timeout)
+    }
+
+    this.started = false
+  }
+
+  /**
+   * Advertise hop relay service in the network.
+   */
+  async _advertiseService () {
+    try {
+      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+      await this.components.getContentRouting().provide(cid)
+    } catch (err: any) {
+      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
+        await this.stop()
+      } else {
+        log.error(err)
+      }
+    }
+  }
+}

package/src/circuit/{listener.js → listener.ts}

@@ -1,33 +1,27 @@
-'use strict'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces'
+import type { ConnectionManager } from '@libp2p/interfaces/registrar'
+import type { Dialer } from '@libp2p/interfaces/dialer'
+import type { Listener } from '@libp2p/interfaces/transport'
+import { Multiaddr } from '@multiformats/multiaddr'
 
-const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
-
-/**
- * @typedef {import('libp2p-interfaces/src/transport/types').Listener} Listener
- */
+export interface ListenerOptions {
+  dialer: Dialer
+  connectionManager: ConnectionManager
+}
 
-/**
- * @param {import('../')} libp2p
- * @returns {Listener} a transport listener
- */
-module.exports = (libp2p) => {
+export function createListener (options: ListenerOptions): Listener {
   const listeningAddrs = new Map()
 
   /**
    * Add swarm handler and listen for incoming connections
-   *
-   * @param {Multiaddr} addr
-   * @returns {Promise<void>}
    */
-  async function listen (addr) {
-    const addrString = String(addr).split('/p2p-circuit').find(a => a !== '')
-
-    const relayConn = await libp2p.dial(new Multiaddr(addrString))
+  async function listen (addr: Multiaddr): Promise<void> {
+    const addrString = addr.toString().split('/p2p-circuit').find(a => a !== '')
+    const relayConn = await options.dialer.dial(new Multiaddr(addrString))
     const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
 
-    listeningAddrs.set(relayConn.remotePeer.toB58String(), relayedAddr)
-    listener.emit('listening')
+    listeningAddrs.set(relayConn.remotePeer.toString(), relayedAddr)
+    listener.dispatchEvent(new CustomEvent('listening'))
   }
 
   /**
@@ -54,20 +48,20 @@ module.exports = (libp2p) => {
     return addrs
   }
 
-  /** @type Listener */
-  const listener = Object.assign(new EventEmitter(), {
-    close: () => Promise.resolve(),
+  const listener: Listener = Object.assign(new EventEmitter(), {
+    close: async () => await Promise.resolve(),
     listen,
     getAddrs
   })
 
   // Remove listeningAddrs when a peer disconnects
-  libp2p.connectionManager.on('peer:disconnect', (connection) => {
-    const deleted = listeningAddrs.delete(connection.remotePeer.toB58String())
+  options.connectionManager.addEventListener('peer:disconnect', (evt) => {
+    const { detail: connection } = evt
+    const deleted = listeningAddrs.delete(connection.remotePeer.toString())
 
     if (deleted) {
       // Announce listen addresses change
-      listener.emit('close')
+      listener.dispatchEvent(new CustomEvent('close'))
     }
   })
 

package/src/circuit/multicodec.ts

@@ -0,0 +1,2 @@
+
+export const RELAY_CODEC = '/libp2p/circuit/relay/0.1.0'