@libp2p/circuit-relay-v2 1.0.24 → 1.0.25-44791342

package/src/transport/discovery.ts

@@ -1,24 +1,28 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { anySignal } from 'any-signal'
+import { raceSignal } from 'race-signal'
 import {
-  RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-import { namespaceToCid } from '../utils.js'
-import type { ComponentLogger, Logger, ContentRouting, PeerId, PeerStore, Startable } from '@libp2p/interface'
-import type { ConnectionManager, Registrar, TransportManager } from '@libp2p/interface-internal'
+import type { ComponentLogger, Logger, PeerId, PeerStore, Startable, TopologyFilter } from '@libp2p/interface'
+import type { ConnectionManager, RandomWalk, Registrar, TransportManager } from '@libp2p/interface-internal'
 
 export interface RelayDiscoveryEvents {
   'relay:discover': CustomEvent<PeerId>
 }
 
 export interface RelayDiscoveryComponents {
-  peerId: PeerId
   peerStore: PeerStore
   connectionManager: ConnectionManager
   transportManager: TransportManager
-  contentRouting: ContentRouting
   registrar: Registrar
   logger: ComponentLogger
+  randomWalk: RandomWalk
+}
+
+export interface RelayDiscoveryInit {
+  filter?: TopologyFilter
 }
 
 /**
@@ -26,23 +30,30 @@ export interface RelayDiscoveryComponents {
  * peers that support the circuit v2 HOP protocol.
  */
 export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> implements Startable {
-  private readonly peerId: PeerId
   private readonly peerStore: PeerStore
-  private readonly contentRouting: ContentRouting
   private readonly registrar: Registrar
+  private readonly connectionManager: ConnectionManager
+  private readonly randomWalk: RandomWalk
   private started: boolean
+  private running: boolean
   private topologyId?: string
   private readonly log: Logger
+  private discoveryController: AbortController
+  private readonly filter?: TopologyFilter
 
-  constructor (components: RelayDiscoveryComponents) {
+  constructor (components: RelayDiscoveryComponents, init: RelayDiscoveryInit = {}) {
     super()
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:discover-relays')
     this.started = false
-    this.peerId = components.peerId
+    this.running = false
     this.peerStore = components.peerStore
-    this.contentRouting = components.contentRouting
     this.registrar = components.registrar
+    this.connectionManager = components.connectionManager
+    this.randomWalk = components.randomWalk
+    this.filter = init.filter
+    this.discoveryController = new AbortController()
+    setMaxListeners(Infinity, this.discoveryController.signal)
   }
 
   isStarted (): boolean {
@@ -53,8 +64,9 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     // 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, {
-      notifyOnTransient: true,
+      filter: this.filter,
       onConnect: (peerId) => {
+        this.log('discovered relay %p', peerId)
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
     })
@@ -62,18 +74,12 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     this.started = true
   }
 
-  afterStart (): void {
-    void this.discover()
-      .catch(err => {
-        this.log.error('error discovering relays', err)
-      })
-  }
-
   stop (): void {
     if (this.topologyId != null) {
       this.registrar.unregister(this.topologyId)
     }
 
+    this.discoveryController?.abort()
     this.started = false
   }
 
@@ -81,54 +87,113 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
    * 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
+   * 1. Check the metadata store for known relays, try to listen on the ones we are already connected to
    * 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> {
-    this.log('searching peer store for relays')
-    const peers = (await this.peerStore.all({
-      filters: [
-        // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
-        (peer) => {
-          return peer.protocols.includes(RELAY_V2_HOP_CODEC)
-        }
-      ],
-      orders: [
-        () => Math.random() < 0.5 ? 1 : -1
-      ]
-    }))
-
-    for (const peer of peers) {
-      this.log('found relay peer %p in content peer store', peer.id)
-      this.safeDispatchEvent('relay:discover', { detail: peer.id })
+  startDiscovery (): void {
+    if (this.running) {
+      return
     }
 
-    this.log('found %d relay peers in peer store', peers.length)
+    this.log('start discovery')
+    this.running = true
+    this.discoveryController = new AbortController()
+    setMaxListeners(Infinity, this.discoveryController.signal)
+
+    Promise.resolve()
+      .then(async () => {
+        this.log('searching peer store for relays')
+
+        const peers = (await this.peerStore.all({
+          filters: [
+            // filter by a list of peers supporting RELAY_V2_HOP and ones we are not listening on
+            (peer) => {
+              return peer.protocols.includes(RELAY_V2_HOP_CODEC)
+            }
+          ],
+          orders: [
+            () => Math.random() < 0.5 ? 1 : -1
+          ]
+        }))
+
+        for (const peer of peers) {
+          this.log.trace('found relay peer %p in peer store', peer.id)
+          this.safeDispatchEvent('relay:discover', { detail: peer.id })
+        }
+
+        this.log('found %d relay peers in peer store', peers.length)
+
+        // perform random walk and dial peers - after identify has run, the network
+        // topology will be notified of new relays
+        const queue = new PeerQueue({
+          concurrency: 5
+        })
+
+        this.log('start random walk')
+        for await (const peer of this.randomWalk.walk({ signal: this.discoveryController.signal })) {
+          this.log.trace('found random peer %p', peer.id)
+
+          if (queue.has(peer.id)) {
+            this.log.trace('random peer %p was already in queue', peer.id)
+
+            // skip peers already in the queue
+            continue
+          }
 
-    try {
-      this.log('searching content routing for relays')
-      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
+          if (this.connectionManager.getConnections(peer.id)?.length > 0) {
+            this.log.trace('random peer %p was already connected', peer.id)
 
-      let found = 0
+            // skip peers we are already connected to
+            continue
+          }
 
-      for await (const provider of this.contentRouting.findProviders(cid)) {
-        if (provider.multiaddrs.length > 0 && !provider.id.equals(this.peerId)) {
-          const peerId = provider.id
+          if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
+            this.log.trace('random peer %p was not dialable', peer.id, peer.multiaddrs.map(ma => ma.toString()))
 
-          found++
-          await this.peerStore.merge(peerId, {
-            multiaddrs: provider.multiaddrs
+            // skip peers we can't dial
+            continue
+          }
+
+          this.log.trace('wait for space in queue for %p', peer.id)
+
+          // pause the random walk until there is space in the queue
+          await raceSignal(queue.onSizeLessThan(10), this.discoveryController.signal)
+
+          this.log('adding random peer %p to dial queue (length: %d)', peer.id, queue.size)
+
+          // dial the peer - this will cause identify to run and our topology to
+          // be notified and we'll attempt to create reservations
+          queue.add(async () => {
+            const signal = anySignal([this.discoveryController.signal, AbortSignal.timeout(5000)])
+            setMaxListeners(Infinity, signal)
+
+            try {
+              await this.connectionManager.openConnection(peer.id, { signal })
+            } finally {
+              signal.clear()
+            }
+          }, {
+            peerId: peer.id,
+            signal: this.discoveryController.signal
           })
+            .catch(err => {
+              this.log.error('error opening connection to random peer %p', peer.id, err)
+            })
+        }
 
-          this.log('found relay peer %p in content routing', peerId)
-          this.safeDispatchEvent('relay:discover', { detail: peerId })
+        await queue.onIdle()
+      })
+      .catch(err => {
+        if (!this.discoveryController.signal.aborted) {
+          this.log.error('failed when finding relays on the network', err)
         }
-      }
+      })
+  }
 
-      this.log('found %d relay peers in content routing', found)
-    } catch (err: any) {
-      this.log.error('failed when finding relays on the network', err)
-    }
+  stopDiscovery (): void {
+    this.log('stop discovery')
+    this.running = false
+    this.discoveryController?.abort()
   }
 }

package/src/transport/index.ts

@@ -1,20 +1,16 @@
-import { type Transport, type Upgrader, type Libp2pEvents, type ComponentLogger, type ConnectionGater, type ContentRouting, type TypedEventTarget, type PeerId, type PeerStore } from '@libp2p/interface'
-import { type RelayDiscoveryComponents } from './discovery.js'
-import { type RelayStoreInit } from './reservation-store.js'
 import { CircuitRelayTransport } from './transport.js'
-import type { AddressManager, ConnectionManager, Registrar } from '@libp2p/interface-internal'
+import type { RelayDiscoveryComponents } from './discovery.js'
+import type { RelayStoreInit } from './reservation-store.js'
+import type { Transport, Upgrader, Libp2pEvents, ConnectionGater, TypedEventTarget, PeerId, TopologyFilter } from '@libp2p/interface'
+import type { AddressManager, Registrar } from '@libp2p/interface-internal'
 
 export interface CircuitRelayTransportComponents extends RelayDiscoveryComponents {
   peerId: PeerId
-  peerStore: PeerStore
   registrar: Registrar
-  connectionManager: ConnectionManager
   upgrader: Upgrader
   addressManager: AddressManager
-  contentRouting: ContentRouting
   connectionGater: ConnectionGater
   events: TypedEventTarget<Libp2pEvents>
-  logger: ComponentLogger
 }
 
 /**
@@ -22,34 +18,48 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
  */
 export interface CircuitRelayTransportInit extends RelayStoreInit {
   /**
-   * The number of peers running diable relays to search for and
-   * connect to. (default: 0)
+   * The number of peers running diable relays to search for and connect to
+   *
+   * @default 0
    */
   discoverRelays?: number
 
+  /**
+   * An optional filter used to prevent duplicate attempts to reserve relay
+   * slots on the same peer
+   */
+  discoveryFilter?: TopologyFilter
+
   /**
    * The maximum number of simultaneous STOP inbound streams that can be open at
-   * once - each inbound relayed connection uses a STOP stream (default: 300)
+   * once - each inbound relayed connection uses a STOP stream
+   *
+   * @default 300
    */
   maxInboundStopStreams?: number
 
   /**
-   * The maximum number of simultaneous STOP outbound streams that can be open at
-   * once. If this transport is used along with the relay server these settings
-   * should be set to the same value (default: 300)
+   * The maximum number of simultaneous STOP outbound streams that can be open
+   * at once. If this transport is used along with the relay server these
+   * settings should be set to the same value
+   *
+   * @default 300
    */
   maxOutboundStopStreams?: number
 
   /**
-   * Incoming STOP requests (e.g. when a remote peer wants to dial us via a relay)
-   * must finish the initial protocol negotiation within this timeout in ms
-   * (default: 30000)
+   * Incoming STOP requests (e.g. when a remote peer wants to dial us via a
+   * relay) must finish the initial protocol negotiation within this timeout in
+   * ms
+   *
+   * @default 30000
    */
   stopTimeout?: number
 
   /**
    * When creating a reservation it must complete within this number of ms
-   * (default: 10000)
+   *
+   * @default 10000
    */
   reservationCompletionTimeout?: number
 }

package/src/transport/reservation-store.ts

@@ -1,15 +1,17 @@
-import { TypedEventEmitter } from '@libp2p/interface'
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
+import { createBloomFilter } from '@libp2p/utils/filters'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
-import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { Reservation } from '../pb/index.js'
 import type { TypedEventTarget, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, PeerId, PeerStore, Startable, Metrics } from '@libp2p/interface'
 import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
+import type { Filter } from '@libp2p/utils/filters'
 
 // allow refreshing a relay reservation if it will expire in the next 10 minutes
 const REFRESH_WINDOW = (60 * 1000) * 10
@@ -69,6 +71,7 @@ interface RelayEntry {
 export interface ReservationStoreEvents {
   'relay:not-enough-relays': CustomEvent
   'relay:removed': CustomEvent<PeerId>
+  'relay:created-reservation': CustomEvent<PeerId>
 }
 
 export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents> implements Startable {
@@ -84,6 +87,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   private readonly reservationCompletionTimeout: number
   private started: boolean
   private readonly log: Logger
+  private readonly relayFilter: Filter
 
   constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
     super()
@@ -96,9 +100,10 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.events = components.events
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
-    this.maxReservationQueueLength = init?.maxReservationQueueLength ?? 100
-    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? 10000
+    this.maxReservationQueueLength = init?.maxReservationQueueLength ?? DEFAULT_MAX_RESERVATION_QUEUE_LENGTH
+    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT
     this.started = false
+    this.relayFilter = createBloomFilter(100)
 
     // ensure we don't listen on multiple relays simultaneously
     this.reserveQueue = new PeerQueue({
@@ -123,6 +128,13 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.started = true
   }
 
+  afterStart (): void {
+    if (this.reservations.size < this.maxDiscoveredRelays) {
+      this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
+      this.safeDispatchEvent('relay:not-enough-relays', {})
+    }
+  }
+
   stop (): void {
     this.reserveQueue.clear()
     this.reservations.forEach(({ timeout }) => {
@@ -134,9 +146,9 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
   /**
    * If the number of current relays is beneath the configured `maxReservations`
-   * value, and the passed peer id is not our own, and we have a non-relayed connection
-   * to the remote, and the remote peer speaks the hop protocol, try to reserve a slot
-   * on the remote peer
+   * value, and the passed peer id is not our own, and we have a non-relayed
+   * connection to the remote, and the remote peer speaks the hop protocol, try
+   * to reserve a slot on the remote peer
    */
   async addRelay (peerId: PeerId, type: RelayType): Promise<void> {
     if (this.peerId.equals(peerId)) {
@@ -145,18 +157,25 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     }
 
     if (this.reserveQueue.size > this.maxReservationQueueLength) {
-      this.log('not adding relay as the queue is full')
+      this.log('not adding potential relay peer %p as the queue is full', peerId)
       return
     }
 
     if (this.reserveQueue.has(peerId)) {
-      this.log('relay peer is already in the reservation queue')
+      this.log('potential relay peer %p is already in the reservation queue', peerId)
+      return
+    }
+
+    if (this.relayFilter.has(peerId.toBytes())) {
+      this.log('potential relay peer %p has failed previously, not trying again', peerId, new Error('where').stack)
       return
     }
 
-    this.log('add relay %p', peerId)
+    this.log('try to reserve relay slot with %p', peerId)
 
     await this.reserveQueue.add(async () => {
+      const start = Date.now()
+
       try {
         // allow refresh of an existing reservation if it is about to expire
         const existingReservation = this.reservations.get(peerId)
@@ -183,6 +202,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         }
 
         const signal = AbortSignal.timeout(this.reservationCompletionTimeout)
+        setMaxListeners(Infinity, signal)
 
         const connection = await this.connectionManager.openConnection(peerId, {
           signal
@@ -230,8 +250,12 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
         // listen on multiaddr that only the circuit transport is listening for
         await this.transportManager.listen([multiaddr(`/p2p/${peerId.toString()}/p2p-circuit`)])
+
+        this.safeDispatchEvent('relay:created-reservation', {
+          detail: peerId
+        })
       } catch (err) {
-        this.log.error('could not reserve slot on %p', peerId, err)
+        this.log.error('could not reserve slot on %p after %dms', peerId, Date.now() - start, err)
 
         // cancel the renewal timeout if it's been set
         const reservation = this.reservations.get(peerId)
@@ -242,6 +266,9 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
         // if listening failed, remove the reservation
         this.reservations.delete(peerId)
+
+        // don't try this peer again
+        this.relayFilter.add(peerId.toBytes())
       }
     }, {
       peerId
@@ -256,6 +283,10 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     return this.reservations.get(peerId)?.reservation
   }
 
+  reservationCount (): number {
+    return this.reservations.size
+  }
+
   async #createReservation (connection: Connection, options: AbortOptions): Promise<Reservation> {
     options.signal?.throwIfAborted()
 
@@ -270,11 +301,12 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     try {
       response = await hopstr.read(options)
     } catch (err: any) {
-      this.log.error('error parsing reserve message response from %p because', connection.remotePeer, err)
       stream.abort(err)
       throw err
     } finally {
-      await stream.close()
+      if (stream.status !== 'closed') {
+        await stream.close(options)
+      }
     }
 
     if (response.status === Status.OK && (response.reservation != null)) {

package/src/transport/transport.ts

@@ -1,11 +1,12 @@
-import { CodeError } from '@libp2p/interface'
+import { CodeError, start, stop } from '@libp2p/interface'
 import { transportSymbol, type Transport, type CreateListenerOptions, type Listener, type Upgrader, type AbortOptions, type ComponentLogger, type Logger, type Connection, type Stream, type ConnectionGater, type PeerId, type PeerStore } from '@libp2p/interface'
+import { peerFilter } from '@libp2p/peer-collections'
 import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
 import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
 import * as mafmt from '@multiformats/mafmt'
 import { multiaddr } from '@multiformats/multiaddr'
 import { pbStream } from 'it-protobuf-stream'
-import { CIRCUIT_PROTO_CODE, ERR_HOP_REQUEST_FAILED, ERR_RELAYED_DIAL, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
+import { CIRCUIT_PROTO_CODE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE, DEFAULT_DISCOVERY_FILTER_SIZE, ERR_HOP_REQUEST_FAILED, ERR_RELAYED_DIAL, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
 import { StopMessage, HopMessage, Status } from '../pb/index.js'
 import { RelayDiscovery } from './discovery.js'
 import { createListener } from './listener.js'
@@ -77,8 +78,12 @@ export class CircuitRelayTransport implements Transport {
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
     this.stopTimeout = init.stopTimeout ?? defaults.stopTimeout
 
-    if (init.discoverRelays != null && init.discoverRelays > 0) {
-      this.discovery = new RelayDiscovery(components)
+    const discoverRelays = init.discoverRelays ?? 0
+
+    if (discoverRelays > 0) {
+      this.discovery = new RelayDiscovery(components, {
+        filter: init.discoveryFilter ?? peerFilter(DEFAULT_DISCOVERY_FILTER_SIZE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE)
+      })
       this.discovery.addEventListener('relay:discover', (evt) => {
         this.reservationStore.addRelay(evt.detail, 'discovered')
           .catch(err => {
@@ -89,10 +94,12 @@ export class CircuitRelayTransport implements Transport {
 
     this.reservationStore = new ReservationStore(components, init)
     this.reservationStore.addEventListener('relay:not-enough-relays', () => {
-      this.discovery?.discover()
-        .catch(err => {
-          this.log.error('could not discover relays', err)
-        })
+      this.discovery?.startDiscovery()
+    })
+    this.reservationStore.addEventListener('relay:created-reservation', () => {
+      if (this.reservationStore.reservationCount() >= discoverRelays) {
+        this.discovery?.stopDiscovery()
+      }
     })
 
     this.started = false
@@ -103,8 +110,6 @@ export class CircuitRelayTransport implements Transport {
   }
 
   async start (): Promise<void> {
-    this.reservationStore.start()
-
     await this.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
       void this.onStop(data).catch(err => {
         this.log.error('error while handling STOP protocol', err)
@@ -116,18 +121,13 @@ export class CircuitRelayTransport implements Transport {
       runOnTransientConnection: true
     })
 
-    await this.discovery?.start()
+    await start(this.discovery, this.reservationStore)
 
     this.started = true
   }
 
-  afterStart (): void {
-    this.discovery?.afterStart()
-  }
-
   async stop (): Promise<void> {
-    this.discovery?.stop()
-    this.reservationStore.stop()
+    await stop(this.discovery, this.reservationStore)
     await this.registrar.unhandle(RELAY_V2_STOP_CODEC)
 
     this.started = false
@@ -231,9 +231,9 @@ export class CircuitRelayTransport implements Transport {
         logger: this.logger
       })
 
-      this.log('new outbound transient connection %a', maConn.remoteAddr)
+      this.log('new outbound relayed connection %a', maConn.remoteAddr)
       return await this.upgrader.upgradeOutbound(maConn, {
-        transient: true
+        transient: status.limit != null
       })
     } catch (err: any) {
       this.log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
@@ -346,9 +346,9 @@ export class CircuitRelayTransport implements Transport {
       logger: this.logger
     })
 
-    this.log('new inbound transient connection %a', maConn.remoteAddr)
+    this.log('new inbound relayed connection %a', maConn.remoteAddr)
     await this.upgrader.upgradeInbound(maConn, {
-      transient: true
+      transient: request.limit != null
     })
     this.log('%s connection %a upgraded', 'inbound', maConn.remoteAddr)
   }

package/dist/src/server/advert-service.d.ts

@@ -1,44 +0,0 @@
-import { TypedEventEmitter } from '@libp2p/interface';
-import type { ComponentLogger, ContentRouting, Startable } from '@libp2p/interface';
-export interface AdvertServiceInit {
-    /**
-     * How long to wait after startup to begin advertising the service
-     * - if some configured content routers take a while to warm up (for
-     * example, the DHT needs some peers to be able to publish) this
-     * value should be high enough that they will have warmed up
-     */
-    bootDelay?: number;
-}
-export interface AdvertServiceComponents {
-    contentRouting: ContentRouting;
-    logger: ComponentLogger;
-}
-export interface AdvertServiceEvents {
-    'advert:success': CustomEvent<unknown>;
-    'advert:error': CustomEvent<Error>;
-}
-export declare class AdvertService extends TypedEventEmitter<AdvertServiceEvents> implements Startable {
-    private readonly contentRouting;
-    private timeout?;
-    private started;
-    private readonly bootDelay;
-    private readonly log;
-    /**
-     * Creates an instance of Relay
-     */
-    constructor(components: AdvertServiceComponents, init?: AdvertServiceInit);
-    isStarted(): boolean;
-    /**
-     * Start Relay service
-     */
-    start(): void;
-    /**
-     * Stop Relay service
-     */
-    stop(): void;
-    /**
-     * Advertise hop relay service in the network.
-     */
-    _advertiseService(): Promise<void>;
-}
-//# sourceMappingURL=advert-service.d.ts.map

package/dist/src/server/advert-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"advert-service.d.ts","sourceRoot":"","sources":["../../../src/server/advert-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAQrD,OAAO,KAAK,EAAE,eAAe,EAAU,cAAc,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAE3F,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,EAAE,cAAc,CAAA;IAC9B,MAAM,EAAE,eAAe,CAAA;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IACtC,cAAc,EAAE,WAAW,CAAC,KAAK,CAAC,CAAA;CACnC;AAED,qBAAa,aAAc,SAAQ,iBAAiB,CAAC,mBAAmB,CAAE,YAAW,SAAS;IAC5F,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAC/C,OAAO,CAAC,OAAO,CAAC,CAAK;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAE5B;;OAEG;gBACU,UAAU,EAAE,uBAAuB,EAAE,IAAI,CAAC,EAAE,iBAAiB;IAS1E,SAAS,IAAK,OAAO;IAIrB;;OAEG;IACH,KAAK,IAAK,IAAI;IAed;;OAEG;IACH,IAAI,IAAK,IAAI;IAQb;;OAEG;IACG,iBAAiB,IAAK,OAAO,CAAC,IAAI,CAAC;CAqB1C"}