Configuration for the NAT traversal handlers.

Default NAT configuration: default relay limits and refresh tuning.

Register the NAT protocol handlers and the circuit client transport on the Switch.

Returns the relay server state (so callers can inspect reservations/circuits) and the circuit client state, which ties transportListen on a p2p-circuit address to the inbound stop streams that arrive over the connection to that relay.

Register the AutoNAT server handler (libp2pautonat/1.0.0).

The dial-back deliberately bypasses the connection pool: reusing the requester's existing connection would always report success. Instead a fresh transport dial + upgrade verifies both reachability and identity, and the probe connection is closed immediately (go-libp2p uses a separate dialer host for the same reason).

Register the Circuit Relay v2 hop handler (libp2pcircuitrelay0.2.0/hop): serve RESERVE and CONNECT requests.

Register the Circuit Relay v2 stop handler (libp2pcircuitrelay0.2.0/stop).

After the CONNECT/OK exchange the stop stream *is* the relayed connection (specsrelaycircuit-v2), so it is handed to the circuit transport's listener for the relay it arrived over. The Switch then upgrades it like any other inbound raw connection.

The relay's advertised limit is not yet enforced (issue #269).

Register the DCUtR handler (libp2pdcutr).

Answers the CONNECT/SYNC exchange with our listen addresses and dials the initiator's addresses through the Switch for the hole punch.

Drop a peer's relay reservation once its last connection to us goes away (specsrelaycircuit-v2): "the reservation remains valid until its expiration, as long as there is an active connection from the peer to the relay. If the peer disconnects, the reservation is no longer valid."

The reservation is bound to the peer, not to the connection the RESERVE arrived on, so a peer holding a second connection keeps it. This matches go-libp2p, whose relay returns early from its disconnect notifiee while Connectedness(p) == Connected.

closeConnection removes the connection from the pool in the same STM transaction that marks it closed, and only then runs the notifiers, so the lookup below never observes the connection being torn down.

Subscribe the DCUtR direct-connection upgrade to new connections.

specsrelayDCUtR: "The protocol starts with the completion of a relay connection from A to B. Upon observing the new connection, the inbound peer (here B) checks the addresses advertised by A via identify." The trigger is therefore an *inbound* connection over a circuit, the same condition go-libp2p's hole punch notifiee applies (Direction == DirInbound && isRelayAddress(RemoteMultiaddr())).

Upgrade a relayed connection to a direct one (specsrelayDCUtR).

Tries the unilateral upgrade first, falling back to the /libp2p/dcutr exchange, and on success schedules the relay connection to close after the grace period. Exposed so it can be driven directly instead of through the notifier.

The peer's advertised addresses that are worth a unilateral direct dial: decodable, not relayed, and publicly routable.

specsrelayDCUtR: "B checks the addresses advertised by A via identify. If that set includes public addresses, then A may be reachable by a direct connection". go-libp2p applies the same pair of filters (!isRelayAddress(a) && manet.IsPublicAddr(a)).

A circuit address is never a target: dialling it would go back through the relay we are trying to get off.

Addresses we put in DCUtR CONNECT: the address reported by the relay that carries this connection, followed by every non-relayed listen address. Scoping the observation to that relay avoids advertising stale mappings learned from unrelated peers. Private listen addresses remain useful to peers on the same LAN and as deterministic test fallbacks.

Tuning for the DCUtR upgrade that runs on an inbound relayed connection.

Three hole punch attempts and a 15s grace period before the relay connection is dropped.

Per-Switch state shared between the circuit transport and the stop protocol handler: one inbound queue per relay we hold a reservation on.

Tuning for client-side reservation refresh (specsrelaycircuit-v2: "the reservation becomes invalid after this time and it's the responsibility of the client to refresh").

Values follow go-libp2p's autorelay relay finder (rsvpExpirationSlack / rsvpRefreshInterval): refresh once the reservation is within rrcMargin of its expiry, checked every rrcPollInterval.

Default refresh tuning: a 2 minute margin, checked every minute.