libp2p 0.42.2-593deefe → 0.42.2-5e63ee2d

package/src/circuit/server/index.ts

@@ -0,0 +1,421 @@
+import { logger } from '@libp2p/logger'
+import { createLimitedRelay } from '../utils.js'
+import {
+  CIRCUIT_PROTO_CODE,
+  DEFAULT_HOP_TIMEOUT,
+  RELAY_SOURCE_TAG
+  , RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC
+} from '../constants.js'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { ReservationStore, ReservationStoreInit } from './reservation-store.js'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import { AdvertService, AdvertServiceComponents, AdvertServiceInit } from './advert-service.js'
+import pDefer from 'p-defer'
+import { pbStream, ProtobufStream } from 'it-pb-stream'
+import { HopMessage, Reservation, Status, StopMessage } from '../pb/index.js'
+import { Multiaddr, multiaddr } from '@multiformats/multiaddr'
+import type { Connection, Stream } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import { RecordEnvelope } from '@libp2p/peer-record'
+import { ReservationVoucherRecord } from './reservation-voucher.js'
+import type { AddressManager } from '@libp2p/interface-address-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { CircuitRelayService, RelayReservation } from '../index.js'
+import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { setMaxListeners } from 'events'
+import type { PeerMap } from '@libp2p/peer-collections'
+
+const log = logger('libp2p:circuit-relay:server')
+
+const isRelayAddr = (ma: Multiaddr): boolean => ma.protoCodes().includes(CIRCUIT_PROTO_CODE)
+
+export interface CircuitRelayServerInit {
+  /**
+   * Incoming hop requests must complete within this time in ms otherwise
+   * the stream will be reset (default: 30s)
+   */
+  hopTimeout?: number
+
+  /**
+   * If true, advertise this service via libp2p content routing to allow
+   * peers to locate us on the network (default: false)
+   */
+  advertise?: boolean | AdvertServiceInit
+
+  /**
+   * Configuration of reservations
+   */
+  reservations?: ReservationStoreInit
+
+  /**
+   * The maximum number of simultaneous HOP inbound streams that can be open at once
+   */
+  maxInboundHopStreams?: number
+
+  /**
+   * The maximum number of simultaneous HOP outbound streams that can be open at once
+   */
+  maxOutboundHopStreams?: number
+}
+
+export interface HopProtocolOptions {
+  connection: Connection
+  request: HopMessage
+  stream: ProtobufStream<Stream>
+}
+
+export interface StopOptions {
+  connection: Connection
+  request: StopMessage
+}
+
+export interface CircuitRelayServerComponents extends AdvertServiceComponents {
+  registrar: Registrar
+  peerStore: PeerStore
+  addressManager: AddressManager
+  peerId: PeerId
+  connectionManager: ConnectionManager
+  connectionGater: ConnectionGater
+}
+
+export interface RelayServerEvents {
+  'relay:reservation': CustomEvent<RelayReservation>
+  'relay:advert:success': CustomEvent<unknown>
+  'relay:advert:error': CustomEvent<Error>
+}
+
+class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Startable, CircuitRelayService {
+  private readonly registrar: Registrar
+  private readonly peerStore: PeerStore
+  private readonly addressManager: AddressManager
+  private readonly peerId: PeerId
+  private readonly connectionManager: ConnectionManager
+  private readonly connectionGater: ConnectionGater
+  private readonly reservationStore: ReservationStore
+  private readonly advertService: AdvertService | undefined
+  private started: boolean
+  private readonly hopTimeout: number
+  private readonly shutdownController: AbortController
+  private readonly maxInboundHopStreams?: number
+  private readonly maxOutboundHopStreams?: number
+
+  /**
+   * Creates an instance of Relay
+   */
+  constructor (components: CircuitRelayServerComponents, init: CircuitRelayServerInit = {}) {
+    super()
+
+    this.registrar = components.registrar
+    this.peerStore = components.peerStore
+    this.addressManager = components.addressManager
+    this.peerId = components.peerId
+    this.connectionManager = components.connectionManager
+    this.connectionGater = components.connectionGater
+    this.started = false
+    this.hopTimeout = init?.hopTimeout ?? DEFAULT_HOP_TIMEOUT
+    this.shutdownController = new AbortController()
+    this.maxInboundHopStreams = init.maxInboundHopStreams
+    this.maxOutboundHopStreams = init.maxOutboundHopStreams
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, this.shutdownController.signal)
+    } catch { }
+
+    if (init.advertise != null && init.advertise !== false) {
+      this.advertService = new AdvertService(components, init.advertise === true ? undefined : init.advertise)
+      this.advertService.addEventListener('advert:success', () => {
+        this.dispatchEvent(new CustomEvent('relay:advert:success'))
+      })
+      this.advertService.addEventListener('advert:error', (evt) => {
+        this.safeDispatchEvent('relay:advert:error', { detail: evt.detail })
+      })
+    }
+
+    this.reservationStore = new ReservationStore(init.reservations)
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  /**
+   * Start Relay service
+   */
+  async start (): Promise<void> {
+    if (this.started) {
+      return
+    }
+
+    // Advertise service if HOP enabled and advertising enabled
+    this.advertService?.start()
+
+    await this.registrar.handle(RELAY_V2_HOP_CODEC, (data) => {
+      void this.onHop(data).catch(err => {
+        log.error(err)
+      })
+    }, {
+      maxInboundStreams: this.maxInboundHopStreams,
+      maxOutboundStreams: this.maxOutboundHopStreams
+    })
+
+    this.reservationStore.start()
+
+    this.started = true
+  }
+
+  /**
+   * Stop Relay service
+   */
+  async stop (): Promise<void> {
+    this.advertService?.stop()
+    this.reservationStore.stop()
+    this.shutdownController.abort()
+    await this.registrar.unhandle(RELAY_V2_HOP_CODEC)
+
+    this.started = false
+  }
+
+  async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
+    log('received circuit v2 hop protocol stream from %s', connection.remotePeer)
+
+    const hopTimeoutPromise = pDefer<HopMessage>()
+    const timeout = setTimeout(() => {
+      hopTimeoutPromise.reject('timed out')
+    }, this.hopTimeout)
+    const pbstr = pbStream(stream)
+
+    try {
+      const request: HopMessage = await Promise.race([
+        pbstr.pb(HopMessage).read(),
+        hopTimeoutPromise.promise
+      ])
+
+      if (request?.type == null) {
+        throw new Error('request was invalid, could not read from stream')
+      }
+
+      log('received', request.type)
+
+      await Promise.race([
+        this.handleHopProtocol({
+          connection,
+          stream: pbstr,
+          request
+        }),
+        hopTimeoutPromise.promise
+      ])
+    } catch (err: any) {
+      log.error('error while handling hop', err)
+      pbstr.pb(HopMessage).write({
+        type: HopMessage.Type.STATUS,
+        status: Status.MALFORMED_MESSAGE
+      })
+      stream.abort(err)
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  async handleHopProtocol ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+    log('received hop message')
+    switch (request.type) {
+      case HopMessage.Type.RESERVE: await this.handleReserve({ stream, request, connection }); break
+      case HopMessage.Type.CONNECT: await this.handleConnect({ stream, request, connection }); break
+      default: {
+        log.error('invalid hop request type %s via peer %s', request.type, connection.remotePeer)
+        stream.pb(HopMessage).write({ type: HopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
+      }
+    }
+  }
+
+  async handleReserve ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+    const hopstr = stream.pb(HopMessage)
+    log('hop reserve request from %s', connection.remotePeer)
+
+    if (isRelayAddr(connection.remoteAddr)) {
+      log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      return
+    }
+
+    if ((await this.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
+      log.error('reservation for %p denied by connection gater', connection.remotePeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      return
+    }
+
+    const result = this.reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
+
+    if (result.status !== Status.OK) {
+      hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
+      return
+    }
+
+    try {
+      // tag relay target peer
+      // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
+      if (result.expire != null) {
+        const ttl = new Date().getTime() - result.expire
+        await this.peerStore.tagPeer(connection.remotePeer, RELAY_SOURCE_TAG, { value: 1, ttl })
+      }
+
+      hopstr.write({
+        type: HopMessage.Type.STATUS,
+        status: Status.OK,
+        reservation: await this.makeReservation(connection.remotePeer, BigInt(result.expire ?? 0)),
+        limit: this.reservationStore.get(connection.remotePeer)?.limit
+      })
+      log('sent confirmation response to %s', connection.remotePeer)
+    } catch (err) {
+      log.error('failed to send confirmation response to %p', connection.remotePeer, err)
+      this.reservationStore.removeReservation(connection.remotePeer)
+    }
+  }
+
+  async makeReservation (
+    remotePeer: PeerId,
+    expire: bigint
+  ): Promise<Reservation> {
+    const addrs = []
+
+    for (const relayAddr of this.addressManager.getAddresses()) {
+      addrs.push(relayAddr.bytes)
+    }
+
+    const voucher = await RecordEnvelope.seal(new ReservationVoucherRecord({
+      peer: remotePeer,
+      relay: this.peerId,
+      expiration: Number(expire)
+    }), this.peerId)
+
+    return {
+      addrs,
+      expire,
+      voucher: voucher.marshal()
+    }
+  }
+
+  async handleConnect ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+    const hopstr = stream.pb(HopMessage)
+
+    if (isRelayAddr(connection.remoteAddr)) {
+      log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      return
+    }
+
+    log('hop connect request from %s', connection.remotePeer)
+
+    let dstPeer: PeerId
+
+    try {
+      if (request.peer == null) {
+        log.error('no peer info in hop connect request')
+        throw new Error('no peer info in request')
+      }
+
+      request.peer.addrs.forEach(multiaddr)
+      dstPeer = peerIdFromBytes(request.peer.id)
+    } catch (err) {
+      log.error('invalid hop connect request via peer %p %s', connection.remotePeer, err)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
+      return
+    }
+
+    if (!this.reservationStore.hasReservation(dstPeer)) {
+      log.error('hop connect denied for destination peer %p not having a reservation for %p with status %s', dstPeer, connection.remotePeer, Status.NO_RESERVATION)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      return
+    }
+
+    if ((await this.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
+      log.error('hop connect for %p to %p denied by connection gater', connection.remotePeer, dstPeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      return
+    }
+
+    const connections = this.connectionManager.getConnections(dstPeer)
+
+    if (connections.length === 0) {
+      log('hop connect denied for destination peer %p not having a connection for %p as there is no destination connection', dstPeer, connection.remotePeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      return
+    }
+
+    const destinationConnection = connections[0]
+
+    const destinationStream = await this.stopHop({
+      connection: destinationConnection,
+      request: {
+        type: StopMessage.Type.CONNECT,
+        peer: {
+          id: connection.remotePeer.toBytes(),
+          addrs: []
+        }
+      }
+    })
+
+    if (destinationStream == null) {
+      log.error('failed to open stream to destination peer %s', destinationConnection?.remotePeer)
+      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
+      return
+    }
+
+    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
+    const sourceStream = stream.unwrap()
+
+    log('connection from %p to %p established - merging streans', connection.remotePeer, dstPeer)
+    const limit = this.reservationStore.get(dstPeer)?.limit
+    // Short circuit the two streams to create the relayed connection
+    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, limit)
+  }
+
+  /**
+   * Send a STOP request to the target peer that the dialing peer wants to contact
+   */
+  async stopHop ({
+    connection,
+    request
+  }: StopOptions): Promise<Stream | undefined> {
+    log('starting circuit relay v2 stop request to %s', connection.remotePeer)
+    const stream = await connection.newStream([RELAY_V2_STOP_CODEC])
+    const pbstr = pbStream(stream)
+    const stopstr = pbstr.pb(StopMessage)
+    stopstr.write(request)
+    let response
+
+    try {
+      response = await stopstr.read()
+    } catch (err) {
+      log.error('error parsing stop message response from %s', connection.remotePeer)
+    }
+
+    if (response == null) {
+      log.error('could not read response from %s', connection.remotePeer)
+      stream.close()
+      return
+    }
+
+    if (response.status === Status.OK) {
+      log('stop request to %s was successful', connection.remotePeer)
+      return pbstr.unwrap()
+    }
+
+    log('stop request failed with code %d', response.status)
+    stream.close()
+  }
+
+  get reservations (): PeerMap<RelayReservation> {
+    return this.reservationStore.reservations
+  }
+}
+
+export function circuitRelayServer (init: CircuitRelayServerInit = {}): (components: CircuitRelayServerComponents) => CircuitRelayService {
+  return (components) => {
+    return new CircuitRelayServer(components, init)
+  }
+}

package/src/circuit/server/reservation-store.ts

@@ -0,0 +1,111 @@
+import { Limit, Status } from '../pb/index.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { PeerMap } from '@libp2p/peer-collections'
+import type { RecursivePartial } from '@libp2p/interfaces'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL, DEFAULT_MAX_RESERVATION_STORE_SIZE, DEFAULT_MAX_RESERVATION_TTL } from '../constants.js'
+import type { RelayReservation } from '../index.js'
+
+export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
+
+export interface ReservationStoreInit {
+  /*
+   * maximum number of reservations allowed, default: 15
+   */
+  maxReservations?: number
+  /*
+   * interval after which stale reservations are cleared, default: 300s
+   */
+  reservationClearInterval?: number
+  /*
+   * apply default relay limits to a new reservation, default: true
+   */
+  applyDefaultLimit?: boolean
+  /**
+   * reservation ttl, default: 2 hours
+   */
+  reservationTtl?: number
+  /**
+   * The maximum time a relayed connection can be open for
+   */
+  defaultDurationLimit?: number
+  /**
+   * The maximum amount of data allowed to be transferred over a relayed connection
+   */
+  defaultDataLimit?: bigint
+}
+
+export type ReservationStoreOptions = RecursivePartial<ReservationStoreInit>
+
+export class ReservationStore implements Startable {
+  public readonly reservations = new PeerMap<RelayReservation>()
+  private _started = false
+  private interval: any
+  private readonly maxReservations: number
+  private readonly reservationClearInterval: number
+  private readonly applyDefaultLimit: boolean
+  private readonly reservationTtl: number
+  private readonly defaultDurationLimit: number
+  private readonly defaultDataLimit: bigint
+
+  constructor (options: ReservationStoreOptions = {}) {
+    this.maxReservations = options.maxReservations ?? DEFAULT_MAX_RESERVATION_STORE_SIZE
+    this.reservationClearInterval = options.reservationClearInterval ?? DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL
+    this.applyDefaultLimit = options.applyDefaultLimit !== false
+    this.reservationTtl = options.reservationTtl ?? DEFAULT_MAX_RESERVATION_TTL
+    this.defaultDurationLimit = options.defaultDurationLimit ?? DEFAULT_DURATION_LIMIT
+    this.defaultDataLimit = options.defaultDataLimit ?? DEFAULT_DATA_LIMIT
+  }
+
+  isStarted (): boolean {
+    return this._started
+  }
+
+  start (): void {
+    if (this._started) {
+      return
+    }
+    this._started = true
+    this.interval = setInterval(
+      () => {
+        const now = (new Date()).getTime()
+        this.reservations.forEach((r, k) => {
+          if (r.expire.getTime() < now) {
+            this.reservations.delete(k)
+          }
+        })
+      },
+      this.reservationClearInterval
+    )
+  }
+
+  stop (): void {
+    clearInterval(this.interval)
+  }
+
+  reserve (peer: PeerId, addr: Multiaddr, limit?: Limit): { status: ReservationStatus, expire?: number } {
+    if (this.reservations.size >= this.maxReservations && !this.reservations.has(peer)) {
+      return { status: Status.RESERVATION_REFUSED }
+    }
+    const expire = new Date(Date.now() + this.reservationTtl)
+    let checkedLimit: Limit | undefined
+    if (this.applyDefaultLimit) {
+      checkedLimit = limit ?? { data: this.defaultDataLimit, duration: this.defaultDurationLimit }
+    }
+    this.reservations.set(peer, { addr, expire, limit: checkedLimit })
+    return { status: Status.OK, expire: expire.getTime() }
+  }
+
+  removeReservation (peer: PeerId): void {
+    this.reservations.delete(peer)
+  }
+
+  hasReservation (dst: PeerId): boolean {
+    return this.reservations.has(dst)
+  }
+
+  get (peer: PeerId): RelayReservation | undefined {
+    return this.reservations.get(peer)
+  }
+}

package/src/circuit/{reservation-voucher.ts → server/reservation-voucher.ts}

@@ -1,6 +1,6 @@
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Record } from '@libp2p/interface-record'
-import { ReservationVoucher } from './pb/index.js'
+import { ReservationVoucher } from '../pb/index.js'
 
 export interface ReservationVoucherOptions {
   relay: PeerId
@@ -22,7 +22,7 @@ export class ReservationVoucherRecord implements Record {
     this.expiration = expiration
   }
 
-  marshal () {
+  marshal (): Uint8Array {
     return ReservationVoucher.encode({
       relay: this.relay.toBytes(),
       peer: this.peer.toBytes(),
@@ -30,7 +30,7 @@ export class ReservationVoucherRecord implements Record {
     })
   }
 
-  equals (other: Record) {
+  equals (other: Record): boolean {
     if (!(other instanceof ReservationVoucherRecord)) {
       return false
     }

package/src/circuit/transport/discovery.ts

@@ -0,0 +1,127 @@
+import { logger } from '@libp2p/logger'
+import { namespaceToCid } from '../utils.js'
+import {
+  RELAY_RENDEZVOUS_NS
+  , RELAY_V2_HOP_CODEC
+} from '../constants.js'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import { EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { Registrar } from '@libp2p/interface-registrar'
+import { createTopology } from '@libp2p/topology'
+
+const log = logger('libp2p:circuit-relay:discover-relays')
+
+export interface RelayDiscoveryEvents {
+  'relay:discover': CustomEvent<PeerId>
+}
+
+export interface RelayDiscoveryComponents {
+  peerId: PeerId
+  peerStore: PeerStore
+  connectionManager: ConnectionManager
+  transportManager: TransportManager
+  contentRouting: ContentRouting
+  registrar: Registrar
+}
+
+/**
+ * ReservationManager automatically makes a circuit v2 reservation on any connected
+ * peers that support the circuit v2 HOP protocol.
+ */
+export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implements Startable {
+  private readonly peerId: PeerId
+  private readonly peerStore: PeerStore
+  private readonly contentRouting: ContentRouting
+  private readonly registrar: Registrar
+  private started: boolean
+  private topologyId?: string
+
+  constructor (components: RelayDiscoveryComponents) {
+    super()
+    this.started = false
+    this.peerId = components.peerId
+    this.peerStore = components.peerStore
+    this.contentRouting = components.contentRouting
+    this.registrar = components.registrar
+  }
+
+  isStarted (): boolean {
+    return this.started
+  }
+
+  async start (): Promise<void> {
+    // register a topology listener for when new peers are encountered
+    // that support the hop protocol
+    this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, createTopology({
+      onConnect: (peerId) => {
+        this.safeDispatchEvent('relay:discover', { detail: peerId })
+      }
+    }))
+
+    void this.discover()
+      .catch(err => {
+        log.error('error listening on relays', err)
+      })
+
+    this.started = true
+  }
+
+  stop (): void {
+    if (this.topologyId != null) {
+      this.registrar.unregister(this.topologyId)
+    }
+
+    this.started = false
+  }
+
+  /**
+   * Try to listen on available hop relay connections.
+   * The following order will happen while we do not have enough relays:
+   *
+   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected
+   * 2. Dial and try to listen on the peers we know that support hop but are not connected
+   * 3. Search the network
+   */
+  async discover (): Promise<void> {
+    log('searching peer store for relays')
+    const peers = (await this.peerStore.all())
+      // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
+      .filter(({ id, protocols }) => protocols.includes(RELAY_V2_HOP_CODEC))
+      .sort(() => Math.random() - 0.5)
+
+    for (const peer of peers) {
+      log('found relay peer %p in content peer store', peer.id)
+      this.safeDispatchEvent('relay:discover', { detail: peer.id })
+    }
+
+    log('found %d relay peers in peer store', peers.length)
+
+    try {
+      log('searching content routing for relays')
+      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+
+      let found = 0
+
+      for await (const provider of this.contentRouting.findProviders(cid)) {
+        if (provider.multiaddrs.length > 0 && !provider.id.equals(this.peerId)) {
+          const peerId = provider.id
+
+          found++
+          log('found relay peer %p in content routing', peerId)
+          await this.peerStore.addressBook.add(peerId, provider.multiaddrs)
+
+          this.safeDispatchEvent('relay:discover', { detail: peerId })
+        }
+      }
+
+      log('found %d relay peers in content routing', found)
+    } catch (err: any) {
+      log.error('failed when finding relays on the network', err)
+    }
+  }
+}