@libp2p/circuit-relay-v2 2.1.5 → 3.0.0

package/src/transport/reservation-store.ts

@@ -1,15 +1,18 @@
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { ListenError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { createBloomFilter } from '@libp2p/utils/filters'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import { PeerQueue } from '@libp2p/utils/peer-queue'
 import { multiaddr } from '@multiformats/multiaddr'
+import { Circuit } from '@multiformats/multiaddr-matcher'
 import { pbStream } from 'it-protobuf-stream'
-import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, KEEP_ALIVE_TAG, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { nanoid } from 'nanoid'
+import { DEFAULT_MAX_RESERVATION_QUEUE_LENGTH, DEFAULT_RESERVATION_COMPLETION_TIMEOUT, DEFAULT_RESERVATION_CONCURRENCY, KEEP_ALIVE_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
+import { DoubleRelayError, HadEnoughRelaysError, RelayQueueFullError } from '../errors.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, Peer } from '@libp2p/interface'
-import type { ConnectionManager, TransportManager } from '@libp2p/interface-internal'
+import type { AbortOptions, TypedEventTarget, Libp2pEvents, ComponentLogger, Logger, PeerId, PeerStore, Startable, Metrics, Peer, Connection } from '@libp2p/interface'
+import type { ConnectionManager } 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
@@ -24,7 +27,6 @@ const REFRESH_TIMEOUT_MIN = 30 * 1000
 export interface ReservationStoreComponents {
   peerId: PeerId
   connectionManager: ConnectionManager
-  transportManager: TransportManager
   peerStore: PeerStore
   events: TypedEventTarget<Libp2pEvents>
   logger: ComponentLogger
@@ -44,11 +46,6 @@ export interface ReservationStoreInit {
    */
   reservationConcurrency?: number
 
-  /**
-   * How many discovered relays to allow in the reservation store
-   */
-  discoverRelays?: number
-
   /**
    * Limit the number of potential relays we will dial
    *
@@ -66,9 +63,25 @@ export interface ReservationStoreInit {
 
 export type RelayType = 'discovered' | 'configured'
 
-interface RelayEntry {
+export interface DiscoveredRelayEntry {
+  timeout: ReturnType<typeof setTimeout>
+  type: 'discovered'
+  reservation: Reservation
+
+  /**
+   * Stores the id of the connection we have to the relay
+   */
+  connection: string
+
+  /**
+   * Stores the identifier returned when the reservation was requested
+   */
+  id: string
+}
+
+export interface ConfiguredRelayEntry {
   timeout: ReturnType<typeof setTimeout>
-  type: RelayType
+  type: 'configured'
   reservation: Reservation
 
   /**
@@ -77,26 +90,33 @@ interface RelayEntry {
   connection: string
 }
 
+export type RelayEntry = DiscoveredRelayEntry | ConfiguredRelayEntry
+
+export interface RelayReservation {
+  relay: PeerId
+  details: RelayEntry
+}
+
 export interface ReservationStoreEvents {
   'relay:not-enough-relays': CustomEvent
-  'relay:removed': CustomEvent<PeerId>
-  'relay:created-reservation': CustomEvent<PeerId>
+  'relay:found-enough-relays': CustomEvent
+  'relay:removed': CustomEvent<RelayReservation>
+  'relay:created-reservation': CustomEvent<RelayReservation>
 }
 
 export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents> implements Startable {
   private readonly peerId: PeerId
   private readonly connectionManager: ConnectionManager
-  private readonly transportManager: TransportManager
   private readonly peerStore: PeerStore
   private readonly events: TypedEventTarget<Libp2pEvents>
-  private readonly reserveQueue: PeerQueue
+  private readonly reserveQueue: PeerQueue<RelayReservation>
   private readonly reservations: PeerMap<RelayEntry>
-  private readonly maxDiscoveredRelays: number
+  private readonly pendingReservations: string[]
   private readonly maxReservationQueueLength: number
   private readonly reservationCompletionTimeout: number
   private started: boolean
   private readonly log: Logger
-  private readonly relayFilter: Filter
+  private relayFilter: Filter
 
   constructor (components: ReservationStoreComponents, init?: ReservationStoreInit) {
     super()
@@ -104,15 +124,14 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.log = components.logger.forComponent('libp2p:circuit-relay:transport:reservation-store')
     this.peerId = components.peerId
     this.connectionManager = components.connectionManager
-    this.transportManager = components.transportManager
     this.peerStore = components.peerStore
     this.events = components.events
     this.reservations = new PeerMap()
-    this.maxDiscoveredRelays = init?.discoverRelays ?? 0
+    this.pendingReservations = []
     this.maxReservationQueueLength = init?.maxReservationQueueLength ?? DEFAULT_MAX_RESERVATION_QUEUE_LENGTH
     this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? DEFAULT_RESERVATION_COMPLETION_TIMEOUT
     this.started = false
-    this.relayFilter = createBloomFilter(100)
+    this.relayFilter = createScalableCuckooFilter(100)
 
     // ensure we don't listen on multiple relays simultaneously
     this.reserveQueue = new PeerQueue({
@@ -132,7 +151,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
         return
       }
 
-      this.#removeReservation(evt.detail.remotePeer, reservation)
+      this.#removeReservation(evt.detail.remotePeer)
         .catch(err => {
           this.log('could not remove relay %p - %e', evt.detail, err)
         })
@@ -153,7 +172,7 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
       .then(async () => {
         const relayPeers: Peer[] = await this.peerStore.all({
           filters: [(peer) => {
-            return peer.tags.has(RELAY_TAG)
+            return peer.tags.has(KEEP_ALIVE_TAG)
           }]
         })
 
@@ -164,17 +183,18 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
           relayPeers.map(async peer => {
             await this.peerStore.merge(peer.id, {
               tags: {
-                [RELAY_TAG]: undefined,
                 [KEEP_ALIVE_TAG]: undefined
               }
             })
           })
         )
 
-        if (this.reservations.size < this.maxDiscoveredRelays) {
-          this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
-          this.safeDispatchEvent('relay:not-enough-relays', {})
-        }
+        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)
@@ -190,36 +210,46 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     this.started = false
   }
 
+  reserveRelay (): string {
+    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: PeerId, type: RelayType): Promise<void> {
+  async addRelay (peerId: PeerId, type: RelayType): Promise<RelayReservation> {
     if (this.peerId.equals(peerId)) {
       this.log.trace('not trying to use self as relay')
-      return
+      throw new ListenError('Cannot use self as relay')
     }
 
     if (this.reserveQueue.size > this.maxReservationQueueLength) {
-      this.log.trace('not adding potential relay peer %p as the queue is full', peerId)
-      return
+      throw new RelayQueueFullError('The reservation queue is full')
     }
 
-    if (this.reserveQueue.has(peerId)) {
+    const existingJob = this.reserveQueue.find(peerId)
+
+    if (existingJob != null) {
       this.log.trace('potential relay peer %p is already in the reservation queue', peerId)
-      return
+      return existingJob.join()
     }
 
     if (this.relayFilter.has(peerId.toMultihash().bytes)) {
-      this.log.trace('potential relay peer %p has failed previously, not trying again', peerId)
-      return
+      throw new ListenError('The relay was previously invalid')
     }
 
     this.log.trace('try to reserve relay slot with %p', peerId)
 
-    await this.reserveQueue.add(async () => {
+    return this.reserveQueue.add(async () => {
       const start = Date.now()
 
       try {
@@ -241,21 +271,17 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
 
           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
+            return {
+              relay: peerId,
+              details: existingReservation
+            } satisfies RelayReservation
           }
 
-          await this.#removeReservation(peerId, existingReservation)
+          await this.#removeReservation(peerId)
         }
 
-        if (type === 'discovered' && [...this.reservations.values()].reduce((acc, curr) => {
-          if (curr.type === 'discovered') {
-            acc++
-          }
-
-          return acc
-        }, 0) >= this.maxDiscoveredRelays) {
-          this.log.trace('already have enough discovered relays')
-          return
+        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)
@@ -265,9 +291,8 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
           signal
         })
 
-        if (connection.remoteAddr.protoNames().includes('p2p-circuit')) {
-          this.log('not creating reservation over relayed connection')
-          return
+        if (Circuit.matches(connection.remoteAddr)) {
+          throw new DoubleRelayError('not creating reservation over relayed connection')
         }
 
         const reservation = await this.#createReservation(connection, {
@@ -288,36 +313,45 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
           this.addRelay(peerId, type)
             .catch(async err => {
               this.log.error('could not refresh reservation to relay %p - %e', peerId, err)
-
-              const reservation = this.reservations.get(peerId)
-
-              if (reservation == null) {
-                this.log.error('did not have reservation after refreshing reservation failed %p', peerId)
-                return
-              }
-
-              await this.#removeReservation(peerId, reservation)
+              await this.#removeReservation(peerId)
             })
             .catch(err => {
               this.log.error('could not remove expired reservation to relay %p - %e', peerId, err)
             })
         }, timeoutDuration)
 
+        let res: RelayEntry
+
+        // 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, {
-          timeout,
-          reservation,
-          type,
-          connection: connection.id
-        })
+        this.reservations.set(peerId, res)
 
         // ensure we don't close the connection to the relay
         await this.peerStore.merge(peerId, {
           tags: {
-            [RELAY_TAG]: {
-              value: 1,
-              ttl: expiration
-            },
             [KEEP_ALIVE_TAG]: {
               value: 1,
               ttl: expiration
@@ -325,28 +359,37 @@ 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/p2p/${this.peerId.toString()}`)])
+        // check to see if we have discovered enough relays
+        this.#checkReservationCount()
+
+        const result: RelayReservation = {
+          relay: peerId,
+          details: res
+        }
 
         this.safeDispatchEvent('relay:created-reservation', {
-          detail: peerId
+          detail: result
         })
-      } catch (err) {
-        this.log.error('could not reserve slot on %p after %dms', peerId, Date.now() - start, err)
 
-        // don't try this peer again
-        this.relayFilter.add(peerId.toMultihash().bytes)
+        return result
+      } catch (err: any) {
+        if (!(type === 'discovered' && err.name === 'HadEnoughRelaysError')) {
+          this.log.error('could not reserve slot on %p after %dms - %e', peerId, Date.now() - start, err)
+        }
 
-        // cancel the renewal timeout if it's been set
-        const reservation = this.reservations.get(peerId)
+        // 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
-        if (reservation != null) {
-          this.#removeReservation(peerId, reservation)
-            .catch(err => {
-              this.log.error('could not remove reservation on %p after reserving slot failed - %e', peerId, err)
-            })
-        }
+        this.#removeReservation(peerId)
+          .catch(err => {
+            this.log.error('could not remove reservation on %p after reserving slot failed - %e', peerId, err)
+          })
+
+        throw err
       }
     }, {
       peerId
@@ -361,16 +404,26 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     return this.reservations.get(peerId)?.reservation
   }
 
-  reservationCount (): number {
-    return this.reservations.size
+  reservationCount (type?: RelayType): number {
+    if (type == null) {
+      return this.reservations.size
+    }
+
+    return [...this.reservations.values()].reduce((acc, curr) => {
+      if (curr.type === type) {
+        acc++
+      }
+
+      return acc
+    }, 0)
   }
 
-  async cancelReservations (): Promise<void> {
-    await Promise.all(
-      [...this.reservations.entries()].map(async ([peerId, reservation]) => {
-        await this.#removeReservation(peerId, reservation)
-      })
-    )
+  cancelReservations (): void {
+    [...this.reservations.values()].forEach(reservation => {
+      clearTimeout(reservation.timeout)
+    })
+
+    this.reservations.clear()
   }
 
   async #createReservation (connection: Connection, options: AbortOptions): Promise<Reservation> {
@@ -380,11 +433,14 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     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: HopMessage
 
     try {
+      this.log.trace('read response from %p', connection.remotePeer)
       response = await hopstr.read(options)
     } catch (err: any) {
       stream.abort(err)
@@ -395,6 +451,8 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
       }
     }
 
+    this.log.trace('read response from %p', 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
@@ -432,9 +490,10 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
   /**
    * Remove listen relay
    */
-  async #removeReservation (peerId: PeerId, reservation: RelayEntry): Promise<void> {
-    if (!this.reservations.has(peerId)) {
-      this.log('not removing relay reservation with %p from local store as we do not have a reservation with this peer', peerId)
+  async #removeReservation (peerId: PeerId): Promise<void> {
+    const reservation = this.reservations.get(peerId)
+
+    if (reservation == null) {
       return
     }
 
@@ -442,19 +501,42 @@ export class ReservationStore extends TypedEventEmitter<ReservationStoreEvents>
     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: {
-        [RELAY_TAG]: undefined,
         [KEEP_ALIVE_TAG]: undefined
       }
     })
 
-    this.safeDispatchEvent('relay:removed', { detail: peerId })
+    this.safeDispatchEvent('relay:removed', {
+      detail: {
+        relay: peerId,
+        details: reservation
+      }
+    })
 
-    if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.log('not enough relays %d/%d', this.reservations.size, this.maxDiscoveredRelays)
-      this.safeDispatchEvent('relay:not-enough-relays', {})
+    // maybe trigger discovery of new relays
+    this.#checkReservationCount()
+  }
+
+  #checkReservationCount (): void {
+    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')
   }
 }

package/src/transport/transport.ts

@@ -9,7 +9,7 @@ import * as Digest from 'multiformats/hashes/digest'
 import { CustomProgressEvent } from 'progress-events'
 import { CIRCUIT_PROTO_CODE, DEFAULT_DISCOVERY_FILTER_ERROR_RATE, DEFAULT_DISCOVERY_FILTER_SIZE, MAX_CONNECTIONS, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
 import { StopMessage, HopMessage, Status } from '../pb/index.js'
-import { CircuitListen, LimitTracker } from '../utils.js'
+import { CircuitListen, CircuitSearch, LimitTracker } from '../utils.js'
 import { RelayDiscovery } from './discovery.js'
 import { createListener } from './listener.js'
 import { ReservationStore } from './reservation-store.js'
@@ -17,7 +17,7 @@ import type { CircuitRelayTransportComponents, CircuitRelayTransportInit } from
 import type { Transport, CreateListenerOptions, Listener, Upgrader, ComponentLogger, Logger, Connection, Stream, ConnectionGater, PeerId, PeerStore, OutboundConnectionUpgradeEvents, DialTransportOptions, OpenConnectionProgressEvents } from '@libp2p/interface'
 import type { AddressManager, ConnectionManager, IncomingStreamData, Registrar, TransportManager } from '@libp2p/interface-internal'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import type { ProgressEvent, ProgressOptions } from 'progress-events'
+import type { ProgressEvent } from 'progress-events'
 
 const isValidStop = (request: StopMessage): request is Required<StopMessage> => {
   if (request.peer == null) {
@@ -33,16 +33,6 @@ const isValidStop = (request: StopMessage): request is Required<StopMessage> =>
   return true
 }
 
-interface ConnectOptions extends ProgressOptions<CircuitRelayDialEvents> {
-  stream: Stream
-  connection: Connection
-  destinationPeer: PeerId
-  destinationAddr: Multiaddr
-  relayAddr: Multiaddr
-  ma: Multiaddr
-  disconnectOnFailure: boolean
-}
-
 const defaults = {
   maxInboundStopStreams: MAX_CONNECTIONS,
   maxOutboundStopStreams: MAX_CONNECTIONS,
@@ -91,28 +81,23 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
     this.stopTimeout = init.stopTimeout ?? defaults.stopTimeout
 
-    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 => {
+    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 => {
+          if (err.name !== 'HadEnoughRelaysError' && err.name !== 'RelayQueueFullError') {
             this.log.error('could not add discovered relay %p', evt.detail, err)
-          })
-      })
-    }
-
+          }
+        })
+    })
     this.reservationStore = new ReservationStore(components, init)
     this.reservationStore.addEventListener('relay:not-enough-relays', () => {
       this.discovery?.startDiscovery()
     })
-    this.reservationStore.addEventListener('relay:created-reservation', () => {
-      if (this.reservationStore.reservationCount() >= discoverRelays) {
-        this.discovery?.stopDiscovery()
-      }
+    this.reservationStore.addEventListener('relay:found-enough-relays', () => {
+      this.discovery?.stopDiscovery()
     })
 
     this.started = false
@@ -192,7 +177,6 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
     const relayPeer = peerIdFromString(relayId)
     const destinationPeer = peerIdFromString(destinationId)
 
-    let disconnectOnFailure = false
     const relayConnections = this.connectionManager.getConnections(relayPeer)
     let relayConnection = relayConnections[0]
 
@@ -203,7 +187,6 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
 
       options.onProgress?.(new CustomProgressEvent('circuit-relay:open-connection'))
       relayConnection = await this.connectionManager.openConnection(relayPeer, options)
-      disconnectOnFailure = true
     } else {
       options.onProgress?.(new CustomProgressEvent('circuit-relay:reuse-connection'))
     }
@@ -212,52 +195,22 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
 
     try {
       options.onProgress?.(new CustomProgressEvent('circuit-relay:open-hop-stream'))
-      stream = await relayConnection.newStream(RELAY_V2_HOP_CODEC)
-
-      return await this.connectV2({
-        stream,
-        connection: relayConnection,
-        destinationPeer,
-        destinationAddr,
-        relayAddr,
-        ma,
-        disconnectOnFailure,
-        onProgress: options.onProgress
-      })
-    } catch (err: any) {
-      this.log.error('circuit relay dial to destination %p via relay %p failed', destinationPeer, relayPeer, err)
+      stream = await relayConnection.newStream(RELAY_V2_HOP_CODEC, options)
 
-      if (stream != null) {
-        stream.abort(err)
-      }
-      disconnectOnFailure && await relayConnection.close()
-      throw err
-    }
-  }
-
-  async connectV2 (
-    {
-      stream, connection, destinationPeer,
-      destinationAddr, relayAddr, ma,
-      disconnectOnFailure,
-      onProgress
-    }: ConnectOptions
-  ): Promise<Connection> {
-    try {
       const pbstr = pbStream(stream)
       const hopstr = pbstr.pb(HopMessage)
 
-      onProgress?.(new CustomProgressEvent('circuit-relay:write-connect-message'))
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:write-connect-message'))
       await hopstr.write({
         type: HopMessage.Type.CONNECT,
         peer: {
           id: destinationPeer.toMultihash().bytes,
           addrs: [multiaddr(destinationAddr).bytes]
         }
-      })
+      }, options)
 
-      onProgress?.(new CustomProgressEvent('circuit-relay:read-connect-response'))
-      const status = await hopstr.read()
+      options.onProgress?.(new CustomProgressEvent('circuit-relay:read-connect-response'))
+      const status = await hopstr.read(options)
 
       if (status.status !== Status.OK) {
         throw new InvalidMessageError(`failed to connect via relay with status ${status?.status?.toString() ?? 'undefined'}`)
@@ -277,12 +230,13 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
       this.log('new outbound relayed connection %a', maConn.remoteAddr)
 
       return await this.upgrader.upgradeOutbound(maConn, {
-        limits: limits.getLimits(),
-        onProgress
+        ...options,
+        limits: limits.getLimits()
       })
     } catch (err: any) {
-      this.log.error(`circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
-      disconnectOnFailure && await connection.close()
+      this.log.error('circuit relay dial to destination %p via relay %p failed', destinationPeer, relayPeer, err)
+      stream?.abort(err)
+
       throw err
     }
   }
@@ -305,7 +259,7 @@ export class CircuitRelayTransport implements Transport<CircuitRelayDialEvents>
     multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs]
 
     return multiaddrs.filter((ma) => {
-      return CircuitListen.exactMatch(ma)
+      return CircuitListen.exactMatch(ma) || CircuitSearch.exactMatch(ma)
     })
   }