fix(noise): rethrow the underlying Error, not its wrapper

NoiseXXCodec.exceptionCaught detected a fatal JVM Error nested in the
causal chain via hasCauseOfType(Error::class) but then did throw cause,
rethrowing whatever Netty handed in. On the encode() path Netty wraps
throwables in EncoderException, so an OutOfMemoryError was rethrown as a
RuntimeException wrapper, downgrading the fatal JVM signal.

Add findCauseOfType to extract the actual Error from the causal chain and
rethrow that. Covered by a test feeding EncoderException(OutOfMemoryError).

Author: lucassaldanha

libp2p/src/main/kotlin/io/libp2p/etc/types/OtherExt.kt

@@ -44,3 +44,9 @@ fun <T : Throwable> Throwable.hasCauseOfType(clazz: KClass<T>) =
     Throwables.getCausalChain(this)
         .filter(clazz::isInstance)
         .any()
+
+fun <T : Throwable> Throwable.findCauseOfType(clazz: KClass<T>): T? =
+    Throwables.getCausalChain(this)
+        .filter(clazz::isInstance)
+        .map { clazz.java.cast(it) }
+        .firstOrNull()

libp2p/src/main/kotlin/io/libp2p/security/noise/NoiseXXCodec.kt

@@ -1,6 +1,7 @@
 package io.libp2p.security.noise
 
 import com.southernstorm.noise.protocol.CipherState
+import io.libp2p.etc.types.findCauseOfType
 import io.libp2p.etc.types.hasCauseOfType
 import io.libp2p.etc.types.toByteArray
 import io.libp2p.security.CantDecryptInboundException
@@ -49,13 +50,17 @@ class NoiseXXCodec(val aliceCipher: CipherState, val bobCipher: CipherState) :
         } else if (cause.hasCauseOfType(SecureChannelError::class)) {
             logger.debug("Invalid Noise content", cause)
             closeAbruptly(ctx)
-        } else if (cause.hasCauseOfType(Error::class)) {
+        } else if (cause.findCauseOfType(Error::class) != null) {
             // A fatal JVM error (e.g. OutOfMemoryError) must never be swallowed: close the
             // channel to release resources, then rethrow so the failure is surfaced rather
             // than downgraded to a single log line while the event loop keeps running.
-            logger.error("Fatal error in Noise channel, closing", cause)
+            // Netty wraps throwables from encode()/decode() (e.g. in EncoderException), so we
+            // extract and rethrow the actual Error rather than the runtime wrapper, which would
+            // otherwise downgrade the fatal JVM signal.
+            val fatal = cause.findCauseOfType(Error::class)!!
+            logger.error("Fatal error in Noise channel, closing", fatal)
             closeAbruptly(ctx)
-            throw cause
+            throw fatal
         } else {
             logger.error("Unexpected error in Noise channel", cause)
             closeAbruptly(ctx)

libp2p/src/test/kotlin/io/libp2p/security/noise/NoiseXXCodecTest.kt

@@ -4,6 +4,7 @@ import com.southernstorm.noise.protocol.CipherState
 import io.mockk.mockk
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.embedded.EmbeddedChannel
+import io.netty.handler.codec.EncoderException
 import org.assertj.core.api.Assertions.assertThat
 import org.assertj.core.api.Assertions.assertThatThrownBy
 import org.junit.jupiter.api.Test
@@ -40,6 +41,19 @@ class NoiseXXCodecTest {
         assertThat(channel.isOpen).isFalse()
     }
 
+    @Test
+    fun `wrapped fatal Error is unwrapped and rethrown as the Error`() {
+        val codec = codec()
+        val (_, ctx) = channelWith(codec)
+        val oom = OutOfMemoryError("Java heap space")
+        // Netty wraps throwables from encode() in an EncoderException; the fatal JVM signal
+        // must be surfaced as the Error itself, not downgraded to the runtime wrapper.
+        val wrapped = EncoderException(oom)
+
+        assertThatThrownBy { codec.exceptionCaught(ctx, wrapped) }
+            .isSameAs(oom)
+    }
+
     @Test
     fun `unexpected runtime exception closes the channel`() {
         val codec = codec()