fix(quic): close the QuicChannel when a dial is cancelled

NetworkImpl.connect() races dials across addresses and cancels the losing
dial futures. QUIC dial() returns the dependent thenApply future; cancelling
it does not propagate upstream to the QUIC connect, so when the handshake
later completes the thenApply body is skipped. The established QuicChannel
was therefore never registered, handed to the caller, nor closed, leaking it
(and its underlying datagram channel) until the idle timeout.

Mirror the TCP transport: register the channel as soon as the connection is
established (before thenApply) so it is tracked and closeable, and close it
explicitly when the returned future is cancelled, cascading to the ephemeral
datagram channel via the existing close listener.

Author: lucassaldanha

libp2p/src/main/kotlin/io/libp2p/transport/quic/QuicTransport.kt

@@ -252,14 +252,18 @@ class QuicTransport(
                         if (ex != null || quicCh == null) {
                             udpChannel.close()
                         } else {
+                            // Register as soon as the connection is established — before the dependent
+                            // thenApply runs — so that a dial cancelled mid-race (whose thenApply is
+                            // skipped) still has its channel tracked, closeable on transport shutdown,
+                            // and counted in activeConnections.
+                            registerChannel(quicCh)
                             quicCh.closeFuture().addListener { udpChannel.close() }
                         }
                     }
             }
 
-        return quicConnFuture
+        val connectionFuture: CompletableFuture<Connection> = quicConnFuture
             .thenApply {
-                registerChannel(it)
                 try {
                     val connection = it.attr(CONNECTION).get() as ConnectionOverNetty
 
@@ -306,6 +310,18 @@ class QuicTransport(
                     throw e
                 }
             }
+
+        // NetworkImpl.connect() cancels losing dial futures in the multi-address race. Cancelling
+        // this dependent future does NOT propagate upstream to quicConnFuture, so if the handshake
+        // later completes, the thenApply body above is skipped and the established QuicChannel is
+        // never registered, handed to the caller, nor closed. Close it explicitly on cancellation
+        // so neither it nor its underlying datagram channel is leaked (mirrors the TCP transport).
+        connectionFuture.whenComplete { _, _ ->
+            if (connectionFuture.isCancelled) {
+                quicConnFuture.thenAccept { it.close() }
+            }
+        }
+        return connectionFuture
     }
 
     private fun registerChannel(ch: Channel) {

libp2p/src/test/java/io/libp2p/transport/quic/QuicServerTestJava.java

@@ -789,4 +789,52 @@ void dialThatFailsAfterHandshakeDoesNotLeakConnection() throws Exception {
     clientTransport.close().get(5, TimeUnit.SECONDS);
     serverTransport.close().get(5, TimeUnit.SECONDS);
   }
+
+  /**
+   * NetworkImpl.connect() races dials across multiple addresses and cancels the losing dial futures
+   * once the first one completes. For QUIC, dial() returns the dependent {@code thenApply} future;
+   * cancelling it does not propagate upstream to the QUIC connect. If the handshake then completes,
+   * the {@code thenApply} body is skipped, so the established QuicChannel is never registered,
+   * handed to the caller, nor closed — it (and its underlying datagram channel) leaks until the
+   * idle timeout. A cancelled dial must promptly close the established QUIC connection.
+   */
+  @Test
+  void cancelledDialClosesEstablishedQuicConnection() throws Exception {
+    String serverListenAddress = "/ip4/127.0.0.1/udp/" + getPort() + "/quic-v1";
+
+    Pair<PrivKey, PubKey> serverKeyPair = KeyKt.generateKeyPair(KeyType.ED25519);
+    Pair<PrivKey, PubKey> clientKeyPair = KeyKt.generateKeyPair(KeyType.ED25519);
+    List<io.libp2p.core.multistream.ProtocolBinding<?>> emptyProtocols = new ArrayList<>();
+
+    QuicTransport serverTransport = QuicTransport.ECDSA(serverKeyPair.component1(), emptyProtocols);
+    QuicTransport clientTransport = QuicTransport.ECDSA(clientKeyPair.component1(), emptyProtocols);
+    serverTransport.initialize();
+    clientTransport.initialize();
+
+    serverTransport
+        .listen(new Multiaddr(serverListenAddress), conn -> {}, null)
+        .get(5, TimeUnit.SECONDS);
+
+    CompletableFuture<Connection> dial =
+        clientTransport.dial(new Multiaddr(serverListenAddress), conn -> {}, null);
+    // Cancel synchronously, before the async handshake completes — the same situation a losing dial
+    // in NetworkImpl.connect() hits.
+    dial.cancel(true);
+
+    // The handshake still completes at the network level, so the QuicChannel is established and
+    // tracked. A leaked channel stays in activeConnections until the 30s idle timeout; a properly
+    // handled cancellation closes it, dropping activeConnections back to zero well inside this
+    // window.
+    long deadline = System.currentTimeMillis() + 15_000;
+    while (clientTransport.getActiveConnections() > 0 && System.currentTimeMillis() < deadline) {
+      Thread.sleep(50);
+    }
+    Assertions.assertEquals(
+        0,
+        clientTransport.getActiveConnections(),
+        "a cancelled dial must close (not leak) the established QUIC connection");
+
+    clientTransport.close().get(5, TimeUnit.SECONDS);
+    serverTransport.close().get(5, TimeUnit.SECONDS);
+  }
 }