fix(quic): cache connection addresses to avoid NPE on freed channel

ConnectionOverNetty resolved local/remote addresses from the underlying
Netty channel on every call. For QUIC the native channel state is freed
on close, after which remoteSocketAddress() returns null and the !! in
QuicTransport.remoteAddress() throws an NPE. This surfaced when a
disconnect handler read the remote address during idle-timeout teardown.

Cache each address on first successful read while the channel is live so
teardown-time callers get a stable value. Add regression tests covering
both addresses surviving a subsequently-freed channel.

Author: lucassaldanha

libp2p/src/main/kotlin/io/libp2p/transport/implementation/ConnectionOverNetty.kt

@@ -20,6 +20,16 @@ open class ConnectionOverNetty(
     private lateinit var muxerSession: StreamMuxer.Session
     private lateinit var secureSession: SecureChannel.Session
 
+    // Addresses are resolved from the underlying Netty channel, but some transports (e.g. QUIC)
+    // free the native channel state on close, after which the socket addresses are no longer
+    // available. We cache the addresses on first successful read while the channel is still live
+    // so that teardown-time callers (e.g. disconnect handlers) get a stable value instead of an NPE.
+    @Volatile
+    private var cachedLocalAddress: Multiaddr? = null
+
+    @Volatile
+    private var cachedRemoteAddress: Multiaddr? = null
+
     init {
         ch.attr(CONNECTION).set(this)
     }
@@ -35,6 +45,9 @@ open class ConnectionOverNetty(
     override fun secureSession() = secureSession
     override fun transport() = nettyTransport
 
-    override fun localAddress(): Multiaddr = nettyTransport.localAddress(nettyChannel)
-    override fun remoteAddress(): Multiaddr = nettyTransport.remoteAddress(nettyChannel)
+    override fun localAddress(): Multiaddr =
+        cachedLocalAddress ?: nettyTransport.localAddress(nettyChannel).also { cachedLocalAddress = it }
+
+    override fun remoteAddress(): Multiaddr =
+        cachedRemoteAddress ?: nettyTransport.remoteAddress(nettyChannel).also { cachedRemoteAddress = it }
 }

libp2p/src/test/kotlin/io/libp2p/transport/implementation/ConnectionOverNettyTest.kt

@@ -0,0 +1,52 @@
+package io.libp2p.transport.implementation
+
+import io.libp2p.core.multiformats.Multiaddr
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import io.netty.channel.embedded.EmbeddedChannel
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class ConnectionOverNettyTest {
+
+    private val localMultiaddr = Multiaddr("/ip4/127.0.0.1/udp/1234/quic-v1")
+    private val remoteMultiaddr = Multiaddr("/ip4/127.0.0.1/udp/5678/quic-v1")
+
+    private fun newConnection(transport: NettyTransport): ConnectionOverNetty =
+        ConnectionOverNetty(EmbeddedChannel(), transport, true)
+
+    @Test
+    fun `remoteAddress is cached after first read so it survives a freed channel`() {
+        val transport = mockk<NettyTransport>()
+        // First read resolves from the live channel; a second resolution would NPE because the
+        // underlying (QUIC) native channel has been freed and remoteSocketAddress() returns null.
+        every { transport.remoteAddress(any()) } returns remoteMultiaddr andThenThrows
+            NullPointerException("channel freed")
+
+        val connection = newConnection(transport)
+
+        // Read once while the channel is "live"
+        assertThat(connection.remoteAddress()).isEqualTo(remoteMultiaddr)
+
+        // A teardown-time read (e.g. a disconnect handler) must return the cached value rather
+        // than hitting the freed channel again.
+        assertThat(connection.remoteAddress()).isEqualTo(remoteMultiaddr)
+
+        verify(exactly = 1) { transport.remoteAddress(any()) }
+    }
+
+    @Test
+    fun `localAddress is cached after first read so it survives a freed channel`() {
+        val transport = mockk<NettyTransport>()
+        every { transport.localAddress(any()) } returns localMultiaddr andThenThrows
+            NullPointerException("channel freed")
+
+        val connection = newConnection(transport)
+
+        assertThat(connection.localAddress()).isEqualTo(localMultiaddr)
+        assertThat(connection.localAddress()).isEqualTo(localMultiaddr)
+
+        verify(exactly = 1) { transport.localAddress(any()) }
+    }
+}