web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/transport/discovery.js

@@ -0,0 +1,186 @@
+import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface';
+import { PeerQueue } from '../../../../utils/dist/src/peer-queue.js';
+import { anySignal } from '../../../../../any-signal/dist/src/index.js';
+import { toString } from '../../../../../uint8arrays/dist/src/to-string.js';
+import { RELAY_V2_HOP_CODEC } from '../constants.js';
+
+/**
+ * ReservationManager automatically makes a circuit v2 reservation on any connected
+ * peers that support the circuit v2 HOP protocol.
+ */
+class RelayDiscovery extends TypedEventEmitter {
+  peerStore;
+  registrar;
+  connectionManager;
+  randomWalk;
+  started;
+  running;
+  topologyId;
+  log;
+  discoveryController;
+  filter;
+  queue;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
+    this.log = components.logger.forComponent('libp2p:circuit-relay:discover-relays');
+    this.started = false;
+    this.running = false;
+    this.peerStore = components.peerStore;
+    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() {
+    return this.started;
+  }
+  async start() {
+    // 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, {
+      filter: this.filter,
+      onConnect: peerId => {
+        this.log.trace('discovered relay %p queue (length: %d, active %d)', peerId, this.queue?.size, this.queue?.running);
+        this.safeDispatchEvent('relay:discover', {
+          detail: peerId
+        });
+      }
+    });
+    this.started = true;
+  }
+  stop() {
+    if (this.topologyId != null) {
+      this.registrar.unregister(this.topologyId);
+    }
+    this.discoveryController?.abort();
+    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 to
+   * 2. Dial and try to listen on the peers we know that support hop but are not connected
+   * 3. Search the network
+   */
+  startDiscovery() {
+    if (this.running) {
+      return;
+    }
+    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: [
+        // randomize
+        () => Math.random() < 0.5 ? 1 : -1,
+        // prefer peers we've connected to in the past
+        (a, b) => {
+          const lastDialA = getLastDial(a);
+          const lastDialB = getLastDial(b);
+          if (lastDialA > lastDialB) {
+            return -1;
+          }
+          if (lastDialB > lastDialA) {
+            return 1;
+          }
+          return 0;
+        }]
+      });
+      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 = this.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;
+        }
+        if (this.connectionManager.getConnections(peer.id)?.length > 0) {
+          this.log.trace('random peer %p was already connected', peer.id);
+          // skip peers we are already connected to
+          continue;
+        }
+        if (!(await this.connectionManager.isDialable(peer.multiaddrs))) {
+          this.log.trace('random peer %p was not dialable', peer.id, peer.multiaddrs.map(ma => ma.toString()));
+          // skip peers we can't dial
+          continue;
+        }
+        if (queue.queued > 10) {
+          this.log.trace('wait for space in queue for %p', peer.id);
+          // pause the random walk until there is space in the queue
+          await queue.onSizeLessThan(10, {
+            signal: this.discoveryController.signal
+          });
+        }
+        this.log('adding random peer %p to dial queue (length: %d, active %d)', peer.id, queue.size, queue.running);
+        // 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('stop random walk');
+      await queue.onIdle();
+    }).catch(err => {
+      if (!this.discoveryController.signal.aborted) {
+        this.log.error('failed when finding relays on the network', err);
+      }
+    });
+  }
+  stopDiscovery() {
+    this.log('stop discovery');
+    this.running = false;
+    this.discoveryController?.abort();
+  }
+}
+/**
+ * Returns the timestamp of the last time we connected to this peer, if we've
+ * not connected to them before return 0
+ */
+function getLastDial(peer) {
+  const lastDial = peer.metadata.get('last-dial-success');
+  if (lastDial == null) {
+    return 0;
+  }
+  return new Date(toString(lastDial)).getTime();
+}
+
+export { RelayDiscovery };

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/transport/index.js

@@ -0,0 +1,10 @@
+import { CircuitRelayTransport } from './transport.js';
+
+function circuitRelayTransport() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => {
+    return new CircuitRelayTransport(components, init);
+  };
+}
+
+export { circuitRelayTransport };

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/transport/listener.js

@@ -0,0 +1,113 @@
+import { TypedEventEmitter, setMaxListeners, ListenError } from '@libp2p/interface';
+import { multiaddr } from '@multiformats/multiaddr';
+import { DEFAULT_RESERVATION_COMPLETION_TIMEOUT } from '../constants.js';
+import { CircuitSearch, CircuitListen } from '../utils.js';
+
+class CircuitRelayTransportListener extends TypedEventEmitter {
+  connectionManager;
+  addressManager;
+  reservationStore;
+  listeningAddrs;
+  log;
+  listenTimeout;
+  reservationId;
+  relay;
+  constructor(components) {
+    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super();
+    this.log = components.logger.forComponent('libp2p:circuit-relay:transport:listener');
+    this.connectionManager = components.connectionManager;
+    this.addressManager = components.addressManager;
+    this.reservationStore = components.reservationStore;
+    this.listeningAddrs = [];
+    this.listenTimeout = init.listenTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT;
+    // remove listening addrs when a relay is removed
+    this.reservationStore.addEventListener('relay:removed', this._onRemoveRelayPeer);
+    this.reservationStore.addEventListener('relay:created-reservation', this._onAddRelayPeer);
+  }
+  _onRemoveRelayPeer = evt => {
+    this.log('relay removed %p our relay %p', evt.detail.relay, this.relay, this.relay?.equals(evt.detail.relay));
+    if (this.relay?.equals(evt.detail.relay) !== true) {
+      return;
+    }
+    this.log('relay peer removed %p', evt.detail.relay);
+    this.listeningAddrs.forEach(ma => {
+      // mark as externally dialable
+      this.addressManager.removeObservedAddr(ma);
+    });
+    this.listeningAddrs = [];
+    // announce listen addresses change
+    this.safeDispatchEvent('listening');
+  };
+  _onAddRelayPeer = evt => {
+    const {
+      details
+    } = evt.detail;
+    if (details.type === 'configured') {
+      return;
+    }
+    if (details.id !== this.reservationId) {
+      return;
+    }
+    this.addedRelay(evt.detail);
+  };
+  async listen(addr) {
+    if (CircuitSearch.exactMatch(addr)) {
+      this.log('searching for circuit relay servers');
+      // start relay discovery
+      this.reservationId = this.reservationStore.reserveRelay();
+    } else if (CircuitListen.exactMatch(addr)) {
+      this.log('listen on specific relay server %a', addr);
+      const signal = AbortSignal.timeout(this.listenTimeout);
+      setMaxListeners(Infinity, signal);
+      // try to make a reservation on one particular relay
+      // remove the circuit part to get the peer id of the relay
+      const relayAddr = addr.decapsulate('/p2p-circuit');
+      const relayConn = await this.connectionManager.openConnection(relayAddr, {
+        signal
+      });
+      if (!this.reservationStore.hasReservation(relayConn.remotePeer)) {
+        this.log('making reservation on peer %p', relayConn.remotePeer);
+        const reservation = await this.reservationStore.addRelay(relayConn.remotePeer, 'configured');
+        this.addedRelay(reservation);
+      }
+    } else {
+      throw new ListenError(`Could not listen on p2p-circuit address "${addr}"`);
+    }
+  }
+  getAddrs() {
+    return [...this.listeningAddrs.values()].flat();
+  }
+  updateAnnounceAddrs() {}
+  async close() {
+    this.reservationStore.cancelReservations();
+    this.listeningAddrs = [];
+    // remove listener
+    this.reservationStore.removeEventListener('relay:removed', this._onRemoveRelayPeer);
+    // announce listen addresses change
+    queueMicrotask(() => {
+      this.safeDispatchEvent('close');
+    });
+  }
+  addedRelay(reservation) {
+    this.log('relay peer added %p', reservation.relay);
+    this.relay = reservation.relay;
+    // add all addresses from the relay reservation
+    this.listeningAddrs = reservation.details.reservation.addrs.map(buf => multiaddr(buf).encapsulate('/p2p-circuit'));
+    this.listeningAddrs.forEach(ma => {
+      // mark as externally dialable
+      this.addressManager.confirmObservedAddr(ma, {
+        type: 'transport'
+      });
+    });
+    // if that succeeded announce listen addresses change
+    queueMicrotask(() => {
+      this.safeDispatchEvent('listening');
+    });
+  }
+}
+function createListener(options) {
+  return new CircuitRelayTransportListener(options);
+}
+
+export { createListener };

package/dist/esm/node_modules/@libp2p/circuit-relay-v2/dist/src/transport/reservation-store.js

@@ -0,0 +1,360 @@
+import { TypedEventEmitter, ListenError, setMaxListeners } from '@libp2p/interface';
+import { PeerQueue } from '../../../../utils/dist/src/peer-queue.js';
+import { multiaddr } from '@multiformats/multiaddr';
+import { Circuit } from '../../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
+import { pbStream } from '../../../../../it-protobuf-stream/dist/src/index.js';
+import { nanoid } from '../../../../../nanoid/index.browser.js';
+import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, KEEP_ALIVE_TAG, RELAY_V2_HOP_CODEC } from '../constants.js';
+import { RelayQueueFullError, HadEnoughRelaysError, DoubleRelayError } from '../errors.js';
+import { HopMessage, Status } from '../pb/index.js';
+import { getExpirationMilliseconds } from '../utils.js';
+import { PeerMap } from '../../../../peer-collections/dist/src/map.js';
+import { createScalableCuckooFilter } from '../../../../utils/dist/src/filters/scalable-cuckoo-filter.js';
+
+// allow refreshing a relay reservation if it will expire in the next 10 minutes
+const REFRESH_WINDOW = 60 * 1000 * 10;
+// try to refresh relay reservations 5 minutes before expiry
+const REFRESH_TIMEOUT = 60 * 1000 * 5;
+// minimum duration before which a reservation must not be refreshed
+const REFRESH_TIMEOUT_MIN = 30 * 1000;
+class ReservationStore extends TypedEventEmitter {
+  peerId;
+  connectionManager;
+  peerStore;
+  events;
+  reserveQueue;
+  reservations;
+  pendingReservations;
+  maxReservationQueueLength;
+  reservationCompletionTimeout;
+  started;
+  log;
+  relayFilter;
+  constructor(components, init) {
+    super();
+    this.log = components.logger.forComponent('libp2p:circuit-relay:transport:reservation-store');
+    this.peerId = components.peerId;
+    this.connectionManager = components.connectionManager;
+    this.peerStore = components.peerStore;
+    this.events = components.events;
+    this.reservations = new PeerMap();
+    this.pendingReservations = [];
+    this.maxReservationQueueLength = init?.maxReservationQueueLength ?? DEFAULT_MAX_RESERVATION_QUEUE_LENGTH;
+    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT;
+    this.started = false;
+    this.relayFilter = createScalableCuckooFilter(100);
+    // ensure we don't listen on multiple relays simultaneously
+    this.reserveQueue = new PeerQueue({
+      concurrency: init?.reservationConcurrency ?? DEFAULT_RESERVATION_CONCURRENCY,
+      metricName: 'libp2p_relay_reservation_queue',
+      metrics: components.metrics
+    });
+    // reservations are only valid while we are still connected to the relay.
+    // if we had a reservation opened via that connection, remove it and maybe
+    // trigger a search for new relays
+    this.events.addEventListener('connection:close', evt => {
+      const reservation = [...this.reservations.values()].find(reservation => reservation.connection === evt.detail.id);
+      if (reservation == null) {
+        return;
+      }
+      this.#removeReservation(evt.detail.remotePeer).catch(err => {
+        this.log('could not remove relay %p - %e', evt.detail, err);
+      });
+    });
+  }
+  isStarted() {
+    return this.started;
+  }
+  start() {
+    this.started = true;
+  }
+  afterStart() {
+    // remove old relay tags
+    void Promise.resolve().then(async () => {
+      const relayPeers = await this.peerStore.all({
+        filters: [peer => {
+          return peer.tags.has(KEEP_ALIVE_TAG);
+        }]
+      });
+      this.log('removing tag from %d old relays', relayPeers.length);
+      // remove old relay tag and redial
+      await Promise.all(relayPeers.map(async peer => {
+        await this.peerStore.merge(peer.id, {
+          tags: {
+            [KEEP_ALIVE_TAG]: undefined
+          }
+        });
+      }));
+      this.log('redialing %d old relays', relayPeers.length);
+      await Promise.all(relayPeers.map(async peer => this.addRelay(peer.id, 'discovered')));
+      this.#checkReservationCount();
+    }).catch(err => {
+      this.log.error(err);
+    });
+  }
+  stop() {
+    this.reserveQueue.clear();
+    this.reservations.forEach(_ref => {
+      let {
+        timeout
+      } = _ref;
+      clearTimeout(timeout);
+    });
+    this.reservations.clear();
+    this.started = false;
+  }
+  reserveRelay() {
+    const id = nanoid();
+    this.pendingReservations.push(id);
+    this.#checkReservationCount();
+    return id;
+  }
+  /**
+   * 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
+   */
+  async addRelay(peerId, type) {
+    if (this.peerId.equals(peerId)) {
+      this.log.trace('not trying to use self as relay');
+      throw new ListenError('Cannot use self as relay');
+    }
+    if (this.reserveQueue.size > this.maxReservationQueueLength) {
+      throw new RelayQueueFullError('The reservation queue is full');
+    }
+    const existingJob = this.reserveQueue.find(peerId);
+    if (existingJob != null) {
+      this.log.trace('potential relay peer %p is already in the reservation queue', peerId);
+      return existingJob.join();
+    }
+    if (this.relayFilter.has(peerId.toMultihash().bytes)) {
+      throw new ListenError('The relay was previously invalid');
+    }
+    this.log.trace('try to reserve relay slot with %p', peerId);
+    return 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);
+        if (existingReservation != null) {
+          const connections = this.connectionManager.getConnections(peerId);
+          let connected = false;
+          if (connections.length === 0) {
+            this.log('already have relay reservation with %p but we are no longer connected', peerId);
+          }
+          if (connections.map(conn => conn.id).includes(existingReservation.connection)) {
+            this.log('already have relay reservation with %p and the original connection is still open', peerId);
+            connected = true;
+          }
+          if (connected && getExpirationMilliseconds(existingReservation.reservation.expire) > REFRESH_WINDOW) {
+            this.log('already have relay reservation with %p but we are still connected and it does not expire soon', peerId);
+            return {
+              relay: peerId,
+              details: existingReservation
+            };
+          }
+          await this.#removeReservation(peerId);
+        }
+        if (type === 'discovered' && this.pendingReservations.length === 0) {
+          throw new HadEnoughRelaysError('Not making reservation on discovered relay because we do not need any more relays');
+        }
+        const signal = AbortSignal.timeout(this.reservationCompletionTimeout);
+        setMaxListeners(Infinity, signal);
+        const connection = await this.connectionManager.openConnection(peerId, {
+          signal
+        });
+        if (Circuit.matches(connection.remoteAddr)) {
+          throw new DoubleRelayError('not creating reservation over relayed connection');
+        }
+        const reservation = await this.#createReservation(connection, {
+          signal
+        });
+        const expiration = getExpirationMilliseconds(reservation.expire);
+        this.log('created reservation on relay peer %p, expiry date is %s', peerId, new Date(Date.now() + expiration).toString());
+        // sets a lower bound on the timeout, and also don't let it go over
+        // 2^31 - 1 (setTimeout will only accept signed 32 bit integers)
+        const timeoutDuration = Math.min(Math.max(expiration - REFRESH_TIMEOUT, REFRESH_TIMEOUT_MIN), Math.pow(2, 31) - 1);
+        const timeout = setTimeout(() => {
+          this.log('refresh reservation to relay %p', peerId);
+          this.addRelay(peerId, type).catch(async err => {
+            this.log.error('could not refresh reservation to relay %p - %e', peerId, err);
+            await this.#removeReservation(peerId);
+          }).catch(err => {
+            this.log.error('could not remove expired reservation to relay %p - %e', peerId, err);
+          });
+        }, timeoutDuration);
+        let res;
+        // assign a reservation id if one was requested
+        if (type === 'discovered') {
+          const id = this.pendingReservations.pop();
+          if (id == null) {
+            throw new HadEnoughRelaysError('Made reservation on relay but did not need any more discovered relays');
+          }
+          res = {
+            timeout,
+            reservation,
+            type,
+            connection: connection.id,
+            id
+          };
+        } else {
+          res = {
+            timeout,
+            reservation,
+            type,
+            connection: connection.id
+          };
+        }
+        // we've managed to create a reservation successfully
+        this.reservations.set(peerId, res);
+        // ensure we don't close the connection to the relay
+        await this.peerStore.merge(peerId, {
+          tags: {
+            [KEEP_ALIVE_TAG]: {
+              value: 1,
+              ttl: expiration
+            }
+          }
+        });
+        // check to see if we have discovered enough relays
+        this.#checkReservationCount();
+        const result = {
+          relay: peerId,
+          details: res
+        };
+        this.safeDispatchEvent('relay:created-reservation', {
+          detail: result
+        });
+        return result;
+      } catch (err) {
+        if (!(type === 'discovered' && err.name === 'HadEnoughRelaysError')) {
+          this.log.error('could not reserve slot on %p after %dms - %e', peerId, Date.now() - start, err);
+        }
+        // don't try this peer again if dialing failed or they do not support
+        // the hop protocol
+        if (err.name === 'DialError' || err.name === 'UnsupportedProtocolError') {
+          this.relayFilter.add(peerId.toMultihash().bytes);
+        }
+        // if listening failed, remove the reservation
+        this.#removeReservation(peerId).catch(err => {
+          this.log.error('could not remove reservation on %p after reserving slot failed - %e', peerId, err);
+        });
+        throw err;
+      }
+    }, {
+      peerId
+    });
+  }
+  hasReservation(peerId) {
+    return this.reservations.has(peerId);
+  }
+  getReservation(peerId) {
+    return this.reservations.get(peerId)?.reservation;
+  }
+  reservationCount(type) {
+    if (type == null) {
+      return this.reservations.size;
+    }
+    return [...this.reservations.values()].reduce((acc, curr) => {
+      if (curr.type === type) {
+        acc++;
+      }
+      return acc;
+    }, 0);
+  }
+  cancelReservations() {
+    [...this.reservations.values()].forEach(reservation => {
+      clearTimeout(reservation.timeout);
+    });
+    this.reservations.clear();
+  }
+  async #createReservation(connection, options) {
+    options.signal?.throwIfAborted();
+    this.log('requesting reservation from %p', connection.remotePeer);
+    const stream = await connection.newStream(RELAY_V2_HOP_CODEC, options);
+    const pbstr = pbStream(stream);
+    const hopstr = pbstr.pb(HopMessage);
+    this.log.trace('send RESERVE to %p', connection.remotePeer);
+    await hopstr.write({
+      type: HopMessage.Type.RESERVE
+    }, options);
+    let response;
+    try {
+      this.log.trace('reading response from %p', connection.remotePeer);
+      response = await hopstr.read(options);
+    } catch (err) {
+      stream.abort(err);
+      throw err;
+    } finally {
+      if (stream.status !== 'closed') {
+        await stream.close(options);
+      }
+    }
+    this.log.trace('read response %o', response);
+    if (response.status === Status.OK && response.reservation != null) {
+      // check that the returned relay has the relay address - this can be
+      // omitted when requesting a reservation from a go-libp2p relay we
+      // already have a reservation on
+      const addresses = new Set();
+      addresses.add(connection.remoteAddr.toString());
+      for (const buf of response.reservation.addrs) {
+        let ma = multiaddr(buf);
+        if (ma.getPeerId() == null) {
+          ma = ma.encapsulate(`/p2p/${connection.remotePeer}`);
+        }
+        // TODO: workaround for https://github.com/libp2p/go-libp2p/issues/3003
+        ma = multiaddr(ma.toString().replace(`/p2p/${connection.remotePeer}/p2p/${connection.remotePeer}`, `/p2p/${connection.remotePeer}`));
+        addresses.add(ma.toString());
+      }
+      response.reservation.addrs = [...addresses].map(str => multiaddr(str).bytes);
+      return response.reservation;
+    }
+    const errMsg = `reservation failed with status ${response.status ?? 'undefined'}`;
+    this.log.error(errMsg);
+    throw new Error(errMsg);
+  }
+  /**
+   * Remove listen relay
+   */
+  async #removeReservation(peerId) {
+    const reservation = this.reservations.get(peerId);
+    if (reservation == null) {
+      return;
+    }
+    this.log('removing relay reservation with %p from local store', peerId);
+    clearTimeout(reservation.timeout);
+    this.reservations.delete(peerId);
+    // discover a new relay for this discovery request
+    if (reservation.type === 'discovered') {
+      this.pendingReservations.push(reservation.id);
+    }
+    // untag the relay
+    await this.peerStore.merge(peerId, {
+      tags: {
+        [KEEP_ALIVE_TAG]: undefined
+      }
+    });
+    this.safeDispatchEvent('relay:removed', {
+      detail: {
+        relay: peerId,
+        details: reservation
+      }
+    });
+    // maybe trigger discovery of new relays
+    this.#checkReservationCount();
+  }
+  #checkReservationCount() {
+    if (this.pendingReservations.length === 0) {
+      this.log.trace('have discovered enough relays');
+      this.reserveQueue.clear();
+      this.safeDispatchEvent('relay:found-enough-relays');
+      return;
+    }
+    this.relayFilter = createScalableCuckooFilter(100);
+    this.log('not discovered enough relays %d/%d', this.reservations.size, this.pendingReservations.length);
+    this.safeDispatchEvent('relay:not-enough-relays');
+  }
+}
+
+export { ReservationStore };