@libp2p/circuit-relay-v2 2.1.3-e99e8f448 → 2.1.4-5d199f9b6

package/src/server/index.ts

@@ -1,13 +1,14 @@
+import { publicKeyToProtobuf } from '@libp2p/crypto/keys'
 import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { peerIdFromMultihash } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr'
 import { pbStream, type ProtobufStream } from 'it-protobuf-stream'
 import * as Digest from 'multiformats/hashes/digest'
-import pDefer from 'p-defer'
 import {
   CIRCUIT_PROTO_CODE,
   DEFAULT_HOP_TIMEOUT,
+  KEEP_ALIVE_SOURCE_TAG,
   MAX_CONNECTIONS,
   RELAY_SOURCE_TAG,
   RELAY_V2_HOP_CODEC,
@@ -18,7 +19,7 @@ import { createLimitedRelay } from '../utils.js'
 import { ReservationStore, type ReservationStoreInit } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
-import type { ComponentLogger, Logger, Connection, Stream, ConnectionGater, PeerId, PeerStore, Startable, PrivateKey, Metrics } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Connection, Stream, ConnectionGater, PeerId, PeerStore, Startable, PrivateKey, Metrics, AbortOptions } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, IncomingStreamData, Registrar } from '@libp2p/interface-internal'
 import type { PeerMap } from '@libp2p/peer-collections'
 
@@ -156,8 +157,6 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       runOnLimitedConnection: true
     })
 
-    this.reservationStore.start()
-
     this.started = true
   }
 
@@ -165,7 +164,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
    * Stop Relay service
    */
   async stop (): Promise<void> {
-    this.reservationStore.stop()
+    this.reservationStore.clear()
     this.shutdownController.abort()
     await this.registrar.unhandle(RELAY_V2_HOP_CODEC)
 
@@ -175,17 +174,13 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
   async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
     this.log('received circuit v2 hop protocol stream from %p', connection.remotePeer)
 
-    const hopTimeoutPromise = pDefer<HopMessage>()
-    const timeout = setTimeout(() => {
-      hopTimeoutPromise.reject('timed out')
-    }, this.hopTimeout)
+    const options = {
+      signal: AbortSignal.timeout(this.hopTimeout)
+    }
     const pbstr = pbStream(stream)
 
     try {
-      const request: HopMessage = await Promise.race([
-        pbstr.pb(HopMessage).read(),
-        hopTimeoutPromise.promise
-      ])
+      const request: HopMessage = await pbstr.pb(HopMessage).read(options)
 
       if (request?.type == null) {
         throw new Error('request was invalid, could not read from stream')
@@ -193,31 +188,26 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
 
       this.log('received', request.type)
 
-      await Promise.race([
-        this.handleHopProtocol({
-          connection,
-          stream: pbstr,
-          request
-        }),
-        hopTimeoutPromise.promise
-      ])
+      await this.handleHopProtocol({
+        connection,
+        stream: pbstr,
+        request
+      }, options)
     } catch (err: any) {
       this.log.error('error while handling hop', err)
       await pbstr.pb(HopMessage).write({
         type: HopMessage.Type.STATUS,
         status: Status.MALFORMED_MESSAGE
-      })
+      }, options)
       stream.abort(err)
-    } finally {
-      clearTimeout(timeout)
     }
   }
 
-  async handleHopProtocol ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+  async handleHopProtocol ({ stream, request, connection }: HopProtocolOptions, options: AbortOptions): Promise<void> {
     this.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
+      case HopMessage.Type.RESERVE: await this.handleReserve({ stream, request, connection }, options); break
+      case HopMessage.Type.CONNECT: await this.handleConnect({ stream, request, connection }, options); break
       default: {
         this.log.error('invalid hop request type %s via peer %p', request.type, connection.remotePeer)
         await stream.pb(HopMessage).write({ type: HopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
@@ -225,37 +215,38 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     }
   }
 
-  async handleReserve ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+  async handleReserve ({ stream, connection }: HopProtocolOptions, options: AbortOptions): Promise<void> {
     const hopstr = stream.pb(HopMessage)
     this.log('hop reserve request from %p', connection.remotePeer)
 
     if (isRelayAddr(connection.remoteAddr)) {
       this.log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
     if ((await this.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
       this.log.error('reservation for %p denied by connection gater', connection.remotePeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
     const result = this.reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
 
-    if (result.status !== Status.OK) {
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
-      return
-    }
-
     try {
+      if (result.status !== Status.OK) {
+        await hopstr.write({ type: HopMessage.Type.STATUS, status: result.status }, options)
+        return
+      }
+
       // tag relay target peer
       // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
       if (result.expire != null) {
         const ttl = (result.expire * 1000) - Date.now()
         await this.peerStore.merge(connection.remotePeer, {
           tags: {
-            [RELAY_SOURCE_TAG]: { value: 1, ttl }
+            [RELAY_SOURCE_TAG]: { value: 1, ttl },
+            [KEEP_ALIVE_SOURCE_TAG]: { value: 1, ttl }
           }
         })
       }
@@ -265,11 +256,22 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
         status: Status.OK,
         reservation: await this.makeReservation(connection.remotePeer, BigInt(result.expire ?? 0)),
         limit: this.reservationStore.get(connection.remotePeer)?.limit
-      })
+      }, options)
       this.log('sent confirmation response to %s', connection.remotePeer)
     } catch (err) {
-      this.log.error('failed to send confirmation response to %p', connection.remotePeer, err)
+      this.log.error('failed to send confirmation response to %p - %e', connection.remotePeer, err)
       this.reservationStore.removeReservation(connection.remotePeer)
+
+      try {
+        await this.peerStore.merge(connection.remotePeer, {
+          tags: {
+            [RELAY_SOURCE_TAG]: undefined,
+            [KEEP_ALIVE_SOURCE_TAG]: undefined
+          }
+        })
+      } catch (err) {
+        this.log.error('failed to untag relay source peer %p - %e', connection.remotePeer, err)
+      }
     }
   }
 
@@ -287,25 +289,34 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       addrs.push(relayAddr.bytes)
     }
 
-    const voucher = await RecordEnvelope.seal(new ReservationVoucherRecord({
+    const envelope = await RecordEnvelope.seal(new ReservationVoucherRecord({
       peer: remotePeer,
       relay: this.peerId,
-      expiration: Number(expire)
+      expiration: expire
     }), this.privateKey)
 
     return {
       addrs,
       expire,
-      voucher: voucher.marshal()
+      voucher: {
+        publicKey: publicKeyToProtobuf(envelope.publicKey),
+        payloadType: envelope.payloadType,
+        payload: {
+          peer: remotePeer.toMultihash().bytes,
+          relay: this.peerId.toMultihash().bytes,
+          expiration: expire
+        },
+        signature: envelope.signature
+      }
     }
   }
 
-  async handleConnect ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
+  async handleConnect ({ stream, request, connection }: HopProtocolOptions, options: AbortOptions): Promise<void> {
     const hopstr = stream.pb(HopMessage)
 
     if (isRelayAddr(connection.remoteAddr)) {
       this.log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
@@ -323,19 +334,21 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
       dstPeer = peerIdFromMultihash(Digest.decode(request.peer.id))
     } catch (err) {
       this.log.error('invalid hop connect request via peer %p %s', connection.remotePeer, err)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, options)
       return
     }
 
-    if (!this.reservationStore.hasReservation(dstPeer)) {
+    const reservation = this.reservationStore.get(dstPeer)
+
+    if (reservation == null) {
       this.log.error('hop connect denied for destination peer %p not having a reservation for %p with status %s', dstPeer, connection.remotePeer, Status.NO_RESERVATION)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION }, options)
       return
     }
 
     if ((await this.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
       this.log.error('hop connect for %p to %p denied by connection gater', connection.remotePeer, dstPeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, options)
       return
     }
 
@@ -343,11 +356,10 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
 
     if (connections.length === 0) {
       this.log('hop connect denied for destination peer %p not having a connection for %p as there is no destination connection', dstPeer, connection.remotePeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION }, options)
       return
     }
 
-    const limit = this.reservationStore.get(dstPeer)?.limit
     const destinationConnection = connections[0]
 
     const destinationStream = await this.stopHop({
@@ -358,26 +370,27 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
           id: connection.remotePeer.toMultihash().bytes,
           addrs: []
         },
-        limit
+        limit: reservation?.limit
       }
-    })
+    }, options)
 
     if (destinationStream == null) {
       this.log.error('failed to open stream to destination peer %p', destinationConnection?.remotePeer)
-      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED }, options)
       return
     }
 
     await hopstr.write({
       type: HopMessage.Type.STATUS,
       status: Status.OK,
-      limit
-    })
+      limit: reservation?.limit
+    }, options)
     const sourceStream = stream.unwrap()
 
     this.log('connection from %p to %p established - merging streams', connection.remotePeer, dstPeer)
+
     // Short circuit the two streams to create the relayed connection
-    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, limit, {
+    createLimitedRelay(sourceStream, destinationStream, this.shutdownController.signal, reservation, {
       log: this.log
     })
   }
@@ -385,29 +398,27 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
   /**
    * Send a STOP request to the target peer that the dialing peer wants to contact
    */
-  async stopHop ({
-    connection,
-    request
-  }: StopOptions): Promise<Stream | undefined> {
+  async stopHop ({ connection, request }: StopOptions, options: AbortOptions): Promise<Stream | undefined> {
     this.log('starting circuit relay v2 stop request to %s', connection.remotePeer)
     const stream = await connection.newStream([RELAY_V2_STOP_CODEC], {
       maxOutboundStreams: this.maxOutboundStopStreams,
-      runOnLimitedConnection: true
+      runOnLimitedConnection: true,
+      ...options
     })
     const pbstr = pbStream(stream)
     const stopstr = pbstr.pb(StopMessage)
-    await stopstr.write(request)
+    await stopstr.write(request, options)
     let response
 
     try {
-      response = await stopstr.read()
+      response = await stopstr.read(options)
     } catch (err) {
       this.log.error('error parsing stop message response from %p', connection.remotePeer)
     }
 
     if (response == null) {
       this.log.error('could not read response from %p', connection.remotePeer)
-      await stream.close()
+      await stream.close(options)
       return
     }
 
@@ -417,7 +428,7 @@ class CircuitRelayServer extends TypedEventEmitter<RelayServerEvents> implements
     }
 
     this.log('stop request failed with code %d', response.status)
-    await stream.close()
+    await stream.close(options)
   }
 
   get reservations (): PeerMap<RelayReservation> {

package/src/server/reservation-store.ts

@@ -1,14 +1,16 @@
 import { trackedPeerMap } from '@libp2p/peer-collections'
-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 { retimeableSignal } from 'retimeable-signal'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, DEFAULT_MAX_RESERVATION_STORE_SIZE, DEFAULT_MAX_RESERVATION_TTL } from '../constants.js'
 import { type Limit, Status } from '../pb/index.js'
 import type { RelayReservation } from '../index.js'
-import type { Metrics, PeerId, Startable } from '@libp2p/interface'
+import type { ComponentLogger, Logger, Metrics, PeerId } from '@libp2p/interface'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
 
 export interface ReservationStoreComponents {
+  logger: ComponentLogger
   metrics?: Metrics
 }
 
@@ -52,20 +54,18 @@ export interface ReservationStoreInit {
   defaultDataLimit?: bigint
 }
 
-export class ReservationStore implements Startable {
+export class ReservationStore {
   public readonly reservations: 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
+  private readonly log: Logger
 
   constructor (components: ReservationStoreComponents, init: ReservationStoreInit = {}) {
+    this.log = components.logger.forComponent('libp2p:circuit-relay:server:reservation-store')
     this.maxReservations = init.maxReservations ?? DEFAULT_MAX_RESERVATION_STORE_SIZE
-    this.reservationClearInterval = init.reservationClearInterval ?? DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL
     this.applyDefaultLimit = init.applyDefaultLimit !== false
     this.reservationTtl = init.reservationTtl ?? DEFAULT_MAX_RESERVATION_TTL
     this.defaultDurationLimit = init.defaultDurationLimit ?? DEFAULT_DURATION_LIMIT
@@ -77,59 +77,55 @@ export class ReservationStore implements Startable {
     })
   }
 
-  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)) {
+    let reservation = this.reservations.get(peer)
+
+    if (this.reservations.size >= this.maxReservations && reservation == null) {
       return { status: Status.RESERVATION_REFUSED }
     }
 
-    const expire = new Date(Date.now() + this.reservationTtl)
+    const expiry = new Date(Date.now() + this.reservationTtl)
     let checkedLimit: Limit | undefined
 
     if (this.applyDefaultLimit) {
-      checkedLimit = limit ?? { data: this.defaultDataLimit, duration: this.defaultDurationLimit }
+      checkedLimit = limit ?? {
+        data: this.defaultDataLimit,
+        duration: this.defaultDurationLimit
+      }
     }
 
-    this.reservations.set(peer, { addr, expire, limit: checkedLimit })
+    if (reservation != null) {
+      this.log('refreshing reservation for client %p', peer)
+      reservation.signal.reset(this.reservationTtl)
+    } else {
+      this.log('creating new reservation for client %p', peer)
+      reservation = {
+        addr,
+        expiry,
+        limit: checkedLimit,
+        signal: retimeableSignal(this.reservationTtl)
+      }
+    }
+
+    this.reservations.set(peer, reservation)
+
+    reservation.signal.addEventListener('abort', () => {
+      this.reservations.delete(peer)
+    })
 
     // return expiry time in seconds
-    return { status: Status.OK, expire: Math.round(expire.getTime() / 1000) }
+    return { status: Status.OK, expire: Math.round(expiry.getTime() / 1000) }
   }
 
   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)
   }
+
+  clear (): void {
+    this.reservations.clear()
+  }
 }

package/src/server/reservation-voucher.ts

@@ -4,7 +4,7 @@ import type { PeerId, Record } from '@libp2p/interface'
 export interface ReservationVoucherOptions {
   relay: PeerId
   peer: PeerId
-  expiration: number
+  expiration: bigint
 }
 
 export class ReservationVoucherRecord implements Record {
@@ -13,7 +13,7 @@ export class ReservationVoucherRecord implements Record {
 
   private readonly relay: PeerId
   private readonly peer: PeerId
-  private readonly expiration: number
+  private readonly expiration: bigint
 
   constructor ({ relay, peer, expiration }: ReservationVoucherOptions) {
     this.relay = relay

package/src/transport/discovery.ts

@@ -66,7 +66,7 @@ export class RelayDiscovery extends TypedEventEmitter<RelayDiscoveryEvents> impl
     this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
       filter: this.filter,
       onConnect: (peerId) => {
-        this.log('discovered relay %p', peerId)
+        this.log.trace('discovered relay %p', peerId)
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
     })

package/src/transport/index.ts

@@ -1,6 +1,6 @@
 import { CircuitRelayTransport } from './transport.js'
 import type { RelayDiscoveryComponents } from './discovery.js'
-import type { RelayStoreInit } from './reservation-store.js'
+import type { ReservationStoreInit } from './reservation-store.js'
 import type { Transport, Upgrader, Libp2pEvents, ConnectionGater, TypedEventTarget, PeerId, TopologyFilter } from '@libp2p/interface'
 import type { AddressManager, Registrar } from '@libp2p/interface-internal'
 
@@ -16,7 +16,7 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
 /**
  * RelayConfig configures the circuit v2 relay transport.
  */
-export interface CircuitRelayTransportInit extends RelayStoreInit {
+export interface CircuitRelayTransportInit extends ReservationStoreInit {
   /**
    * The number of peers running diable relays to search for and connect to
    *

package/src/transport/listener.ts

@@ -14,7 +14,7 @@ export interface CircuitRelayTransportListenerComponents {
 
 class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
-  private readonly relayStore: ReservationStore
+  private readonly reservationStore: ReservationStore
   private readonly listeningAddrs: PeerMap<Multiaddr[]>
   private readonly log: Logger
 
@@ -23,15 +23,26 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
 
     this.log = components.logger.forComponent('libp2p:circuit-relay:transport:listener')
     this.connectionManager = components.connectionManager
-    this.relayStore = components.relayStore
+    this.reservationStore = components.relayStore
     this.listeningAddrs = new PeerMap()
 
     // remove listening addrs when a relay is removed
-    this.relayStore.addEventListener('relay:removed', this._onRemoveRelayPeer)
+    this.reservationStore.addEventListener('relay:removed', this._onRemoveRelayPeer)
   }
 
   _onRemoveRelayPeer = (evt: CustomEvent<PeerId>): void => {
-    this.#removeRelayPeer(evt.detail)
+    const had = this.listeningAddrs.has(evt.detail)
+
+    this.log('relay peer removed %p - had reservation', evt.detail, had)
+
+    if (!had) {
+      return
+    }
+
+    this.listeningAddrs.delete(evt.detail)
+
+    // announce listen addresses change
+    this.safeDispatchEvent('listening')
   }
 
   async listen (addr: Multiaddr): Promise<void> {
@@ -41,14 +52,14 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
     const relayAddr = addr.decapsulate('/p2p-circuit')
     const relayConn = await this.connectionManager.openConnection(relayAddr)
 
-    if (!this.relayStore.hasReservation(relayConn.remotePeer)) {
+    if (!this.reservationStore.hasReservation(relayConn.remotePeer)) {
       this.log('making reservation on peer %p', relayConn.remotePeer)
       // addRelay calls transportManager.listen which calls this listen method
-      await this.relayStore.addRelay(relayConn.remotePeer, 'configured')
+      await this.reservationStore.addRelay(relayConn.remotePeer, 'configured')
       return
     }
 
-    const reservation = this.relayStore.getReservation(relayConn.remotePeer)
+    const reservation = this.reservationStore.getReservation(relayConn.remotePeer)
 
     if (reservation == null) {
       throw new ListenError('Did not have reservation after making reservation')
@@ -60,11 +71,11 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
     }
 
     // add all addresses from the relay reservation
-    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs.map(buf => {
-      return multiaddr(buf).encapsulate('/p2p-circuit')
-    }))
+    this.listeningAddrs.set(relayConn.remotePeer, reservation.addrs
+      .map(buf => multiaddr(buf).encapsulate('/p2p-circuit'))
+    )
 
-    this.safeDispatchEvent('listening', {})
+    this.safeDispatchEvent('listening')
   }
 
   getAddrs (): Multiaddr[] {
@@ -72,22 +83,14 @@ class CircuitRelayTransportListener extends TypedEventEmitter<ListenerEvents> im
   }
 
   async close (): Promise<void> {
+    await this.reservationStore.cancelReservations()
+    this.listeningAddrs.clear()
 
-  }
-
-  #removeRelayPeer (peerId: PeerId): void {
-    const had = this.listeningAddrs.has(peerId)
-
-    this.log('relay peer removed %p - had reservation', peerId, had)
+    // remove listener
+    this.reservationStore.removeEventListener('relay:removed', this._onRemoveRelayPeer)
 
-    this.listeningAddrs.delete(peerId)
-
-    if (had) {
-      this.log.trace('removing relay event listener for peer %p', peerId)
-      this.relayStore.removeEventListener('relay:removed', this._onRemoveRelayPeer)
-      // Announce listen addresses change
-      this.safeDispatchEvent('close', {})
-    }
+    // announce listen addresses change
+    this.safeDispatchEvent('close')
   }
 }