libp2p 0.45.9 → 0.46.0

package/src/autonat/index.ts

@@ -1,3 +1,24 @@
+/**
+ * @packageDocumentation
+ *
+ * Use the `autoNATService` function to add support for the [AutoNAT protocol](https://docs.libp2p.io/concepts/nat/autonat/)
+ * to libp2p.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { autoNATService } from 'libp2p/autonat'
+ *
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   services: {
+ *     autoNAT: autoNATService()
+ *   }
+ * })
+ * ```
+ */
+
 import { setMaxListeners } from 'events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
@@ -17,15 +38,15 @@ import {
   PROTOCOL_NAME, PROTOCOL_PREFIX, PROTOCOL_VERSION, REFRESH_INTERVAL, STARTUP_DELAY, TIMEOUT
 } from './constants.js'
 import { Message } from './pb/index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerInfo } from '@libp2p/interface/peer-info'
+import type { PeerRouting } from '@libp2p/interface/peer-routing'
+import type { Startable } from '@libp2p/interface/startable'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:autonat')
 
@@ -258,7 +279,7 @@ class DefaultAutoNATService implements Startable {
             .filter(ma => {
               const isFromSameHost = ma.toOptions().host === data.connection.remoteAddr.toOptions().host
 
-              log.trace('request to dial %s was sent from %s is same host %s', ma, data.connection.remoteAddr, isFromSameHost)
+              log.trace('request to dial %a was sent from %a is same host %s', ma, data.connection.remoteAddr, isFromSameHost)
               // skip any Multiaddrs where the target node's IP does not match the sending node's IP
               return isFromSameHost
             })
@@ -281,7 +302,7 @@ class DefaultAutoNATService implements Startable {
             .filter(ma => {
               const isSupportedTransport = Boolean(self.components.transportManager.transportForMultiaddr(ma))
 
-              log.trace('transport for %s is supported %s', ma, isSupportedTransport)
+              log.trace('transport for %a is supported %s', ma, isSupportedTransport)
               // skip any Multiaddrs that have transports we do not support
               return isSupportedTransport
             })
@@ -324,7 +345,7 @@ class DefaultAutoNATService implements Startable {
               })
 
               if (!connection.remoteAddr.equals(multiaddr)) {
-                log.error('tried to dial %s but dialed %s', multiaddr, connection.remoteAddr)
+                log.error('tried to dial %a but dialed %a', multiaddr, connection.remoteAddr)
                 throw new Error('Unexpected remote address')
               }
 

package/src/circuit-relay/index.ts

@@ -1,5 +1,41 @@
+/**
+ * @packageDocumentation
+ *
+ * The `circuitRelayTransport` allows libp2p to dial and listen on [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)
+ * addresses.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { circuitRelayTransport } from 'libp2p/circuit-relay'
+ *
+ * const node = await createLibp2p({
+ *   transports: [
+ *     circuitRelayTransport()
+ *   ]
+ * })
+ * ```
+ *
+ * The `circuitRelayServer` function allows libp2p to function as a [Circuit Relay](https://docs.libp2p.io/concepts/nat/circuit-relay/)
+ * server.  This will not work in browsers.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createLibp2p } from 'libp2p'
+ * import { circuitRelayServer } from 'libp2p/circuit-relay'
+ *
+ * const node = await createLibp2p({
+ *   services: [
+ *     circuitRelay: circuitRelayServer()
+ *   ]
+ * })
+ * ```
+ */
+
 import type { Limit } from './pb/index.js'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { EventEmitter } from '@libp2p/interface/events'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 

package/src/circuit-relay/server/advert-service.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import pRetry from 'p-retry'
 import { codes } from '../../errors.js'
@@ -7,8 +7,8 @@ import {
   RELAY_RENDEZVOUS_NS
 } from '../constants.js'
 import { namespaceToCid } from '../utils.js'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { Startable } from '@libp2p/interface/startable'
 
 const log = logger('libp2p:circuit-relay:advert-service')
 

package/src/circuit-relay/server/index.ts

@@ -1,17 +1,18 @@
 import { setMaxListeners } from 'events'
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { RecordEnvelope } from '@libp2p/peer-record'
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr'
-import { pbStream, type ProtobufStream } from 'it-pb-stream'
+import { pbStream, type ProtobufStream } from 'it-protobuf-stream'
 import pDefer from 'p-defer'
 import { MAX_CONNECTIONS } from '../../connection-manager/constants.js'
 import {
   CIRCUIT_PROTO_CODE,
   DEFAULT_HOP_TIMEOUT,
-  RELAY_SOURCE_TAG
-  , RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC
+  RELAY_SOURCE_TAG,
+  RELAY_V2_HOP_CODEC,
+  RELAY_V2_STOP_CODEC
 } from '../constants.js'
 import { HopMessage, type Reservation, Status, StopMessage } from '../pb/index.js'
 import { createLimitedRelay } from '../utils.js'
@@ -19,14 +20,14 @@ import { AdvertService, type AdvertServiceComponents, type AdvertServiceInit } f
 import { ReservationStore, type ReservationStoreInit } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
 import type { PeerMap } from '@libp2p/peer-collections'
 
 const log = logger('libp2p:circuit-relay:server')
@@ -172,7 +173,8 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       })
     }, {
       maxInboundStreams: this.maxInboundHopStreams,
-      maxOutboundStreams: this.maxOutboundHopStreams
+      maxOutboundStreams: this.maxOutboundHopStreams,
+      runOnTransientConnection: true
     })
 
     this.reservationStore.start()
@@ -193,7 +195,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
   }
 
   async onHop ({ connection, stream }: IncomingStreamData): Promise<void> {
-    log('received circuit v2 hop protocol stream from %s', connection.remotePeer)
+    log('received circuit v2 hop protocol stream from %p', connection.remotePeer)
 
     const hopTimeoutPromise = pDefer<HopMessage>()
     const timeout = setTimeout(() => {
@@ -223,7 +225,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       ])
     } catch (err: any) {
       log.error('error while handling hop', err)
-      pbstr.pb(HopMessage).write({
+      await pbstr.pb(HopMessage).write({
         type: HopMessage.Type.STATUS,
         status: Status.MALFORMED_MESSAGE
       })
@@ -239,32 +241,32 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       case HopMessage.Type.RESERVE: await this.handleReserve({ stream, request, connection }); break
       case HopMessage.Type.CONNECT: await this.handleConnect({ stream, request, connection }); break
       default: {
-        log.error('invalid hop request type %s via peer %s', request.type, connection.remotePeer)
-        stream.pb(HopMessage).write({ type: HopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
+        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 })
       }
     }
   }
 
   async handleReserve ({ stream, request, connection }: HopProtocolOptions): Promise<void> {
     const hopstr = stream.pb(HopMessage)
-    log('hop reserve request from %s', connection.remotePeer)
+    log('hop reserve request from %p', connection.remotePeer)
 
     if (isRelayAddr(connection.remoteAddr)) {
       log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
       return
     }
 
     if ((await this.connectionGater.denyInboundRelayReservation?.(connection.remotePeer)) === true) {
       log.error('reservation for %p denied by connection gater', connection.remotePeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
       return
     }
 
     const result = this.reservationStore.reserve(connection.remotePeer, connection.remoteAddr)
 
     if (result.status !== Status.OK) {
-      hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: result.status })
       return
     }
 
@@ -280,7 +282,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
         })
       }
 
-      hopstr.write({
+      await hopstr.write({
         type: HopMessage.Type.STATUS,
         status: Status.OK,
         reservation: await this.makeReservation(connection.remotePeer, BigInt(result.expire ?? 0)),
@@ -325,11 +327,11 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
 
     if (isRelayAddr(connection.remoteAddr)) {
       log.error('relay reservation over circuit connection denied for peer: %p', connection.remotePeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
       return
     }
 
-    log('hop connect request from %s', connection.remotePeer)
+    log('hop connect request from %p', connection.remotePeer)
 
     let dstPeer: PeerId
 
@@ -343,19 +345,19 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       dstPeer = peerIdFromBytes(request.peer.id)
     } catch (err) {
       log.error('invalid hop connect request via peer %p %s', connection.remotePeer, err)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
       return
     }
 
     if (!this.reservationStore.hasReservation(dstPeer)) {
       log.error('hop connect denied for destination peer %p not having a reservation for %p with status %s', dstPeer, connection.remotePeer, Status.NO_RESERVATION)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
       return
     }
 
     if ((await this.connectionGater.denyOutboundRelayedConnection?.(connection.remotePeer, dstPeer)) === true) {
       log.error('hop connect for %p to %p denied by connection gater', connection.remotePeer, dstPeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
       return
     }
 
@@ -363,7 +365,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
 
     if (connections.length === 0) {
       log('hop connect denied for destination peer %p not having a connection for %p as there is no destination connection', dstPeer, connection.remotePeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.NO_RESERVATION })
       return
     }
 
@@ -381,12 +383,12 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     })
 
     if (destinationStream == null) {
-      log.error('failed to open stream to destination peer %s', destinationConnection?.remotePeer)
-      hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
+      log.error('failed to open stream to destination peer %p', destinationConnection?.remotePeer)
+      await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.CONNECTION_FAILED })
       return
     }
 
-    hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
+    await hopstr.write({ type: HopMessage.Type.STATUS, status: Status.OK })
     const sourceStream = stream.unwrap()
 
     log('connection from %p to %p established - merging streans', connection.remotePeer, dstPeer)
@@ -404,32 +406,33 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
   }: StopOptions): Promise<Stream | undefined> {
     log('starting circuit relay v2 stop request to %s', connection.remotePeer)
     const stream = await connection.newStream([RELAY_V2_STOP_CODEC], {
-      maxOutboundStreams: this.maxOutboundStopStreams
+      maxOutboundStreams: this.maxOutboundStopStreams,
+      runOnTransientConnection: true
     })
     const pbstr = pbStream(stream)
     const stopstr = pbstr.pb(StopMessage)
-    stopstr.write(request)
+    await stopstr.write(request)
     let response
 
     try {
       response = await stopstr.read()
     } catch (err) {
-      log.error('error parsing stop message response from %s', connection.remotePeer)
+      log.error('error parsing stop message response from %p', connection.remotePeer)
     }
 
     if (response == null) {
-      log.error('could not read response from %s', connection.remotePeer)
-      stream.close()
+      log.error('could not read response from %p', connection.remotePeer)
+      await stream.close()
       return
     }
 
     if (response.status === Status.OK) {
-      log('stop request to %s was successful', connection.remotePeer)
+      log('stop request to %p was successful', connection.remotePeer)
       return pbstr.unwrap()
     }
 
     log('stop request failed with code %d', response.status)
-    stream.close()
+    await stream.close()
   }
 
   get reservations (): PeerMap<RelayReservation> {

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

@@ -2,9 +2,9 @@ import { PeerMap } 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 { type Limit, Status } from '../pb/index.js'
 import type { RelayReservation } from '../index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { RecursivePartial } from '@libp2p/interfaces'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { RecursivePartial } from '@libp2p/interface'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Startable } from '@libp2p/interface/startable'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED

package/src/circuit-relay/server/reservation-voucher.ts

@@ -1,6 +1,6 @@
 import { ReservationVoucher } from '../pb/index.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Record } from '@libp2p/interface-record'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Record } from '@libp2p/interface/record'
 
 export interface ReservationVoucherOptions {
   relay: PeerId

package/src/circuit-relay/transport/discovery.ts

@@ -1,18 +1,17 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
-import { createTopology } from '@libp2p/topology'
 import {
   RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
 import { namespaceToCid } from '../utils.js'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Registrar } from '@libp2p/interface-registrar'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:circuit-relay:discover-relays')
 
@@ -57,11 +56,11 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
   async start (): Promise<void> {
     // register a topology listener for when new peers are encountered
     // that support the hop protocol
-    this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, createTopology({
+    this.topologyId = await this.registrar.register(RELAY_V2_HOP_CODEC, {
       onConnect: (peerId) => {
         this.safeDispatchEvent('relay:discover', { detail: peerId })
       }
-    }))
+    })
 
     void this.discover()
       .catch(err => {

package/src/circuit-relay/transport/index.ts

@@ -1,11 +1,11 @@
-import { symbol, type Upgrader, type Listener, type Transport, type CreateListenerOptions } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { symbol, type Transport, type CreateListenerOptions, type Listener, type Upgrader } from '@libp2p/interface/transport'
 import { logger } from '@libp2p/logger'
 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-pb-stream'
+import { pbStream } from 'it-protobuf-stream'
 import { MAX_CONNECTIONS } from '../../connection-manager/constants.js'
 import { codes } from '../../errors.js'
 import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
@@ -13,17 +13,16 @@ import { StopMessage, HopMessage, Status } from '../pb/index.js'
 import { RelayDiscovery, type RelayDiscoveryComponents } from './discovery.js'
 import { createListener } from './listener.js'
 import { type RelayStoreInit, ReservationStore } from './reservation-store.js'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Connection, Stream } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-internal/registrar'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport')
@@ -86,11 +85,25 @@ export interface CircuitRelayTransportInit extends RelayStoreInit {
    * 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)
+   */
+  stopTimeout?: number
+
+  /**
+   * When creating a reservation it must complete within this number of ms
+   * (default: 10000)
+   */
+  reservationCompletionTimeout?: number
 }
 
 const defaults = {
   maxInboundStopStreams: MAX_CONNECTIONS,
-  maxOutboundStopStreams: MAX_CONNECTIONS
+  maxOutboundStopStreams: MAX_CONNECTIONS,
+  stopTimeout: 30000
 }
 
 class CircuitRelayTransport implements Transport {
@@ -105,6 +118,7 @@ class CircuitRelayTransport implements Transport {
   private readonly reservationStore: ReservationStore
   private readonly maxInboundStopStreams: number
   private readonly maxOutboundStopStreams?: number
+  private readonly stopTimeout: number
   private started: boolean
 
   constructor (components: CircuitRelayTransportComponents, init: CircuitRelayTransportInit) {
@@ -117,6 +131,7 @@ class CircuitRelayTransport implements Transport {
     this.connectionGater = components.connectionGater
     this.maxInboundStopStreams = init.maxInboundStopStreams ?? defaults.maxInboundStopStreams
     this.maxOutboundStopStreams = init.maxOutboundStopStreams ?? defaults.maxOutboundStopStreams
+    this.stopTimeout = init.stopTimeout ?? defaults.stopTimeout
 
     if (init.discoverRelays != null && init.discoverRelays > 0) {
       this.discovery = new RelayDiscovery(components)
@@ -149,11 +164,13 @@ class CircuitRelayTransport implements Transport {
 
     await this.registrar.handle(RELAY_V2_STOP_CODEC, (data) => {
       void this.onStop(data).catch(err => {
-        log.error(err)
+        log.error('error while handling STOP protocol', err)
+        data.stream.abort(err)
       })
     }, {
       maxInboundStreams: this.maxInboundStopStreams,
-      maxOutboundStreams: this.maxOutboundStopStreams
+      maxOutboundStreams: this.maxOutboundStopStreams,
+      runOnTransientConnection: true
     })
 
     this.started = true
@@ -245,7 +262,7 @@ class CircuitRelayTransport implements Transport {
     try {
       const pbstr = pbStream(stream)
       const hopstr = pbstr.pb(HopMessage)
-      hopstr.write({
+      await hopstr.write({
         type: HopMessage.Type.CONNECT,
         peer: {
           id: destinationPeer.toBytes(),
@@ -259,16 +276,16 @@ class CircuitRelayTransport implements Transport {
         throw new CodeError(`failed to connect via relay with status ${status?.status?.toString() ?? 'undefined'}`, codes.ERR_HOP_REQUEST_FAILED)
       }
 
-      // TODO: do something with limit and transient connection
-
       const maConn = streamToMaConnection({
         stream: pbstr.unwrap(),
         remoteAddr: ma,
         localAddr: relayAddr.encapsulate(`/p2p-circuit/p2p/${this.peerId.toString()}`)
       })
 
-      log('new outbound connection %s', maConn.remoteAddr)
-      return await this.upgrader.upgradeOutbound(maConn)
+      log('new outbound transient connection %a', maConn.remoteAddr)
+      return await this.upgrader.upgradeOutbound(maConn, {
+        transient: true
+      })
     } catch (err) {
       log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${connection.remotePeer.toString()} failed`, err)
       disconnectOnFailure && await connection.close()
@@ -304,50 +321,71 @@ class CircuitRelayTransport implements Transport {
    * An incoming STOP request means a remote peer wants to dial us via a relay
    */
   async onStop ({ connection, stream }: IncomingStreamData): Promise<void> {
-    const pbstr = pbStream(stream)
-    const request = await pbstr.readPB(StopMessage)
-    log('received circuit v2 stop protocol request from %s', connection.remotePeer)
+    const signal = AbortSignal.timeout(this.stopTimeout)
+    const pbstr = pbStream(stream).pb(StopMessage)
+    const request = await pbstr.read({
+      signal
+    })
+
+    log('new circuit relay v2 stop stream from %p with type %s', connection.remotePeer, request.type)
 
     if (request?.type === undefined) {
+      log.error('type was missing from circuit v2 stop protocol request from %s', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, {
+        signal
+      })
+      await stream.close()
       return
     }
 
-    const stopstr = pbstr.pb(StopMessage)
-    log('new circuit relay v2 stop stream from %s', connection.remotePeer)
-
     // Validate the STOP request has the required input
     if (request.type !== StopMessage.Type.CONNECT) {
-      log.error('invalid stop connect request via peer %s', connection.remotePeer)
-      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE })
+      log.error('invalid stop connect request via peer %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.UNEXPECTED_MESSAGE }, {
+        signal
+      })
+      await stream.close()
       return
     }
 
     if (!isValidStop(request)) {
-      log.error('invalid stop connect request via peer %s', connection.remotePeer)
-      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE })
+      log.error('invalid stop connect request via peer %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.MALFORMED_MESSAGE }, {
+        signal
+      })
+      await stream.close()
       return
     }
 
     const remotePeerId = peerIdFromBytes(request.peer.id)
 
     if ((await this.connectionGater.denyInboundRelayedConnection?.(connection.remotePeer, remotePeerId)) === true) {
-      stopstr.write({ type: StopMessage.Type.STATUS, status: Status.PERMISSION_DENIED })
+      log.error('connection gater denied inbound relayed connection from %p', connection.remotePeer)
+      await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.PERMISSION_DENIED }, {
+        signal
+      })
+      await stream.close()
       return
     }
 
-    stopstr.write({ type: StopMessage.Type.STATUS, status: Status.OK })
+    log.trace('sending success response to %p', connection.remotePeer)
+    await pbstr.write({ type: StopMessage.Type.STATUS, status: Status.OK }, {
+      signal
+    })
 
     const remoteAddr = connection.remoteAddr.encapsulate(`/p2p-circuit/p2p/${remotePeerId.toString()}`)
     const localAddr = this.addressManager.getAddresses()[0]
     const maConn = streamToMaConnection({
-      stream: pbstr.unwrap(),
+      stream: pbstr.unwrap().unwrap(),
       remoteAddr,
       localAddr
     })
 
-    log('new inbound connection %s', maConn.remoteAddr)
-    await this.upgrader.upgradeInbound(maConn)
-    log('%s connection %s upgraded', 'inbound', maConn.remoteAddr)
+    log('new inbound transient connection %a', maConn.remoteAddr)
+    await this.upgrader.upgradeInbound(maConn, {
+      transient: true
+    })
+    log('%s connection %a upgraded', 'inbound', maConn.remoteAddr)
   }
 }