chore: split processSinglePayment in smaller methods

Author: jvsena42

app/src/main/java/to/bitkit/services/CoreService.kt

@@ -291,128 +291,140 @@ class ActivityService(
     }
 
     private suspend fun processSinglePayment(payment: PaymentDetails, forceUpdate: Boolean) {
-        try {
-            val state = when (payment.status) {
-                PaymentStatus.FAILED -> PaymentState.FAILED
-                PaymentStatus.PENDING -> PaymentState.PENDING
-                PaymentStatus.SUCCEEDED -> PaymentState.SUCCEEDED
+        val state = when (payment.status) {
+            PaymentStatus.FAILED -> PaymentState.FAILED
+            PaymentStatus.PENDING -> PaymentState.PENDING
+            PaymentStatus.SUCCEEDED -> PaymentState.SUCCEEDED
+        }
+
+        when (val kind = payment.kind) {
+            is PaymentKind.Onchain -> {
+                processOnchainPayment(kind = kind, payment = payment, forceUpdate = forceUpdate)
             }
 
-            when (val kind = payment.kind) {
-                is PaymentKind.Onchain -> {
-                    var isConfirmed = false
-                    var confirmedTimestamp: ULong? = null
-
-                    val status = kind.status
-                    if (status is ConfirmationStatus.Confirmed) {
-                        isConfirmed = true
-                        confirmedTimestamp = status.timestamp
-                    }
-
-                    // Ensure confirmTimestamp is at least equal to timestamp when confirmed
-                    val timestamp = payment.latestUpdateTimestamp
-
-                    if (isConfirmed && confirmedTimestamp != null && confirmedTimestamp < timestamp) {
-                        confirmedTimestamp = timestamp
-                    }
-
-                    val existingActivity = getActivityById(payment.id)
-                    if (existingActivity != null &&
-                        existingActivity is Activity.Onchain &&
-                        (existingActivity.v1.updatedAt ?: 0u) > payment.latestUpdateTimestamp
-                    ) {
-                        return
-                    }
-
-                    val onChain = if (existingActivity is Activity.Onchain) {
-                        existingActivity.v1.copy(
-                            confirmed = isConfirmed,
-                            confirmTimestamp = confirmedTimestamp,
-                            updatedAt = timestamp,
-                        )
-                    } else {
-                        OnchainActivity(
-                            id = payment.id,
-                            txType = payment.direction.toPaymentType(),
-                            txId = kind.txid,
-                            value = payment.amountSats ?: 0u,
-                            fee = (payment.feePaidMsat ?: 0u) / 1000u,
-                            feeRate = 1u,
-                            address = "Loading...",
-                            confirmed = isConfirmed,
-                            timestamp = timestamp,
-                            isBoosted = false,
-                            isTransfer = false,
-                            doesExist = true,
-                            confirmTimestamp = confirmedTimestamp,
-                            channelId = null,
-                            transferTxId = null,
-                            createdAt = timestamp,
-                            updatedAt = timestamp,
-                        )
-                    }
-
-                    if (onChain.id in cacheStore.data.first().deletedActivities && !forceUpdate) {
-                        Logger.debug("Activity ${onChain.id} was already deleted, skipping", context = TAG)
-                        return
-                    }
-
-                    if (existingActivity != null) {
-                        updateActivity(payment.id, Activity.Onchain(onChain))
-                    } else {
-                        upsertActivity(Activity.Onchain(onChain))
-                    }
-                }
+            is PaymentKind.Bolt11 -> {
+                processBolt11(kind = kind, payment = payment, state = state)
+            }
 
-                is PaymentKind.Bolt11 -> {
-                    // Skip pending inbound payments, just means an invoice was created
-                    if (
-                        payment.status == PaymentStatus.PENDING &&
-                        payment.direction == PaymentDirection.INBOUND
-                    ) {
-                        return
-                    }
-
-                    val existingActivity = getActivityById(payment.id)
-                    if (
-                        existingActivity as? Activity.Lightning != null &&
-                        (existingActivity.v1.updatedAt ?: 0u) > payment.latestUpdateTimestamp
-                    ) {
-                        return
-                    }
-
-                    val ln = if (existingActivity is Activity.Lightning) {
-                        existingActivity.v1.copy(
-                            updatedAt = payment.latestUpdateTimestamp,
-                            status = state
-                        )
-                    } else {
-                        LightningActivity(
-                            id = payment.id,
-                            txType = payment.direction.toPaymentType(),
-                            status = state,
-                            value = payment.amountSats ?: 0u,
-                            fee = (payment.feePaidMsat ?: 0u) / 1000u,
-                            invoice = kind.bolt11 ?: "Loading...",
-                            message = kind.description.orEmpty(),
-                            timestamp = payment.latestUpdateTimestamp,
-                            preimage = kind.preimage,
-                            createdAt = payment.latestUpdateTimestamp,
-                            updatedAt = payment.latestUpdateTimestamp,
-                        )
-                    }
+            else -> Unit // Handle spontaneous payments if needed
+        }
+    }
 
-                    if (getActivityById(payment.id) != null) {
-                        updateActivity(payment.id, Activity.Lightning(ln))
-                    } else {
-                        upsertActivity(Activity.Lightning(ln))
-                    }
-                }
+    private suspend fun processBolt11(
+        kind: PaymentKind.Bolt11,
+        payment: PaymentDetails,
+        state: PaymentState,
+    ) {
+        // Skip pending inbound payments, just means an invoice was created
+        if (
+            payment.status == PaymentStatus.PENDING &&
+            payment.direction == PaymentDirection.INBOUND
+        ) {
+            return
+        }
 
-                else -> Unit // Handle spontaneous payments if needed
-            }
-        } catch (e: Throwable) {
-            throw e
+        val existingActivity = getActivityById(payment.id)
+        if (
+            existingActivity as? Activity.Lightning != null &&
+            (existingActivity.v1.updatedAt ?: 0u) > payment.latestUpdateTimestamp
+        ) {
+            return
+        }
+
+        val ln = if (existingActivity is Activity.Lightning) {
+            existingActivity.v1.copy(
+                updatedAt = payment.latestUpdateTimestamp,
+                status = state
+            )
+        } else {
+            LightningActivity(
+                id = payment.id,
+                txType = payment.direction.toPaymentType(),
+                status = state,
+                value = payment.amountSats ?: 0u,
+                fee = (payment.feePaidMsat ?: 0u) / 1000u,
+                invoice = kind.bolt11 ?: "Loading...",
+                message = kind.description.orEmpty(),
+                timestamp = payment.latestUpdateTimestamp,
+                preimage = kind.preimage,
+                createdAt = payment.latestUpdateTimestamp,
+                updatedAt = payment.latestUpdateTimestamp,
+            )
+        }
+
+        if (getActivityById(payment.id) != null) {
+            updateActivity(payment.id, Activity.Lightning(ln))
+        } else {
+            upsertActivity(Activity.Lightning(ln))
+        }
+    }
+
+    private suspend fun processOnchainPayment(
+        kind: PaymentKind.Onchain,
+        payment: PaymentDetails,
+        forceUpdate: Boolean,
+    ) {
+        var isConfirmed = false
+        var confirmedTimestamp: ULong? = null
+
+        val status = kind.status
+        if (status is ConfirmationStatus.Confirmed) {
+            isConfirmed = true
+            confirmedTimestamp = status.timestamp
+        }
+
+        // Ensure confirmTimestamp is at least equal to timestamp when confirmed
+        val timestamp = payment.latestUpdateTimestamp
+
+        if (isConfirmed && confirmedTimestamp != null && confirmedTimestamp < timestamp) {
+            confirmedTimestamp = timestamp
+        }
+
+        val existingActivity = getActivityById(payment.id)
+        if (existingActivity != null &&
+            existingActivity is Activity.Onchain &&
+            (existingActivity.v1.updatedAt ?: 0u) > payment.latestUpdateTimestamp
+        ) {
+            return
+        }
+
+        val onChain = if (existingActivity is Activity.Onchain) {
+            existingActivity.v1.copy(
+                confirmed = isConfirmed,
+                confirmTimestamp = confirmedTimestamp,
+                updatedAt = timestamp,
+            )
+        } else {
+            OnchainActivity(
+                id = payment.id,
+                txType = payment.direction.toPaymentType(),
+                txId = kind.txid,
+                value = payment.amountSats ?: 0u,
+                fee = (payment.feePaidMsat ?: 0u) / 1000u,
+                feeRate = 1u,
+                address = "Loading...",
+                confirmed = isConfirmed,
+                timestamp = timestamp,
+                isBoosted = false,
+                isTransfer = false,
+                doesExist = true,
+                confirmTimestamp = confirmedTimestamp,
+                channelId = null,
+                transferTxId = null,
+                createdAt = timestamp,
+                updatedAt = timestamp,
+            )
+        }
+
+        if (onChain.id in cacheStore.data.first().deletedActivities && !forceUpdate) {
+            Logger.debug("Activity ${onChain.id} was already deleted, skipping", context = TAG)
+            return
+        }
+
+        if (existingActivity != null) {
+            updateActivity(payment.id, Activity.Onchain(onChain))
+        } else {
+            upsertActivity(Activity.Onchain(onChain))
         }
     }