fix: address error type feedback

Author: pwltr

app/src/main/java/to/bitkit/ext/PaymentFailureReasonExt.kt

@@ -57,6 +57,8 @@ fun Throwable.toSendFailureMessage(context: Context): String {
 }
 
 fun Throwable.toCompactFailureType(): String {
+    if (this is LdkError) return compactType ?: UNKNOWN_FAILURE_TYPE
+
     val rawValue = message?.trim()?.takeIf { it.isNotEmpty() }
         ?: this::class.simpleName
         ?: UNKNOWN_FAILURE_TYPE
@@ -88,12 +90,26 @@ private fun String.snakeToLowerCamel(): String {
 }
 
 private fun String.compactFailureType(): String {
-    val unwrappedOptional = removeSurrounding("Optional(", ")")
-    val unwrappedNodeError = unwrappedOptional.removeSurrounding("NodeError(", ")")
-    return unwrappedNodeError
+    val strippedPrefixes = this
+        .removePrefix("LDK Node error:")
+        .removePrefix("LDK Build error:")
+        .trim()
+    val type = strippedPrefixes
         .substringBefore("(")
-        .substringAfterLast(".")
         .trim()
+        .trimEnd('.')
+        .trim()
+
+    return type.toCompactTypeName()
+}
+
+private fun String.toCompactTypeName(): String {
+    if (isBlank()) return UNKNOWN_FAILURE_TYPE
+    if (none { it.isWhitespace() || it == '-' || it == '_' }) return this
+
+    return split(Regex("[\\s_-]+"))
+        .filter { it.isNotBlank() }
+        .joinToString("") { it.replaceFirstChar(Char::titlecase) }
         .ifBlank { UNKNOWN_FAILURE_TYPE }
 }
 
@@ -102,8 +118,6 @@ private fun String.looksInternalPaymentError(): Boolean {
 }
 
 private val INTERNAL_PAYMENT_ERROR_MARKERS = listOf(
-    "Optional(",
-    "NodeError",
     "DuplicatePayment",
     "PaymentFailureReason",
     "ldknode",

app/src/main/java/to/bitkit/utils/Errors.kt

@@ -33,11 +33,14 @@ class LdkError(private val inner: LdkException) : AppError("Unknown LDK error.")
     constructor(inner: NodeException) : this(LdkException.Node(inner))
 
     override val message get() = inner.message ?: super.message
+    val compactType get() = inner.compactType
 
     sealed interface LdkException {
         val message: String?
+        val compactType: String?
 
         class Build(exception: BuildException) : LdkException {
+            override val compactType = exception::class.simpleName
             override val message = when (exception) {
                 is BuildException.InvalidChannelMonitor -> "Invalid channel monitor."
                 is BuildException.InvalidSystemTime -> "Invalid system time."
@@ -57,6 +60,7 @@ class LdkError(private val inner: LdkException) : AppError("Unknown LDK error.")
         }
 
         class Node(exception: NodeException) : LdkException {
+            override val compactType = exception::class.simpleName
             override val message = when (exception) {
                 is NodeException.AlreadyRunning -> "The node is already running."
                 is NodeException.NotRunning -> "The node is not running."

app/src/test/java/to/bitkit/ext/PaymentFailureReasonExtTest.kt

@@ -2,13 +2,16 @@ package to.bitkit.ext
 
 import android.content.Context
 import org.junit.Test
+import org.lightningdevkit.ldknode.NodeException
 import org.lightningdevkit.ldknode.PaymentFailureReason
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 import to.bitkit.R
 import to.bitkit.models.SendFailureDetails
+import to.bitkit.utils.LdkError
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
 import kotlin.test.assertTrue
 
 class PaymentFailureReasonExtTest {
@@ -38,13 +41,34 @@ class PaymentFailureReasonExtTest {
         whenever(context.getString(R.string.wallet__payment_failed_description)).thenReturn(message)
 
         assertEquals(message, Exception("  ").toSendFailureMessage(context))
-        assertEquals(message, Exception("Optional(NodeError(DuplicatePayment))").toSendFailureMessage(context))
+        assertEquals(message, LdkError(NodeException.DuplicatePayment("Duplicate payment.")).toSendFailureMessage(context))
     }
 
     @Test
-    fun `compact failure types omit optional and node error wrappers`() {
+    fun `payment failure reason compact failure types use lower camel case`() {
         assertEquals("routeNotFound", PaymentFailureReason.ROUTE_NOT_FOUND.toCompactFailureType())
-        assertEquals("DuplicatePayment", Exception("Optional(NodeError(DuplicatePayment))").toCompactFailureType())
+    }
+
+    @Test
+    fun `compact failure types use android ldk error classes`() {
+        assertEquals(
+            "DuplicatePayment",
+            LdkError(NodeException.DuplicatePayment("Duplicate payment.")).toCompactFailureType(),
+        )
+        assertEquals(
+            "InvalidCustomTlvs",
+            LdkError(NodeException.InvalidCustomTlvs("Invalid custom TLVs")).toCompactFailureType(),
+        )
+    }
+
+    @Test
+    fun `compact failure types fall back to the exception class name`() {
+        assertEquals("IllegalStateException", IllegalStateException().toCompactFailureType())
+    }
+
+    @Test
+    fun `compact failure types ignore sentence punctuation`() {
+        assertNotEquals("Unknown", Exception("Payment sending failed.").toCompactFailureType())
     }
 
     @Test