Integrate LDK events

app/src/main/java/to/bitkit/data/CacheStore.kt

@@ -83,22 +83,6 @@ class CacheStore @Inject constructor(
         }
     }
 
-    suspend fun addActivityToPendingDelete(activityId: String) {
-        if (activityId.isBlank()) return
-        if (activityId in store.data.first().activitiesPendingDelete) return
-        store.updateData {
-            it.copy(activitiesPendingDelete = it.activitiesPendingDelete + activityId)
-        }
-    }
-
-    suspend fun removeActivityFromPendingDelete(activityId: String) {
-        if (activityId.isBlank()) return
-        if (activityId !in store.data.first().activitiesPendingDelete) return
-        store.updateData {
-            it.copy(activitiesPendingDelete = it.activitiesPendingDelete - activityId)
-        }
-    }
-
     suspend fun addActivityToPendingBoost(pendingBoostActivity: PendingBoostActivity) {
         if (pendingBoostActivity in store.data.first().pendingBoostActivities) return
         store.updateData {
@@ -137,7 +121,6 @@ data class AppCacheData(
     val balance: BalanceState? = null,
     val backupStatuses: Map<BackupCategory, BackupItemStatus> = mapOf(),
     val deletedActivities: List<String> = listOf(),
-    val activitiesPendingDelete: List<String> = listOf(),
     val lastLightningPaymentId: String? = null,
     val pendingBoostActivities: List<PendingBoostActivity> = listOf(),
 )

app/src/main/java/to/bitkit/domain/commands/NotifyPaymentReceivedHandler.kt

@@ -39,7 +39,7 @@ class NotifyPaymentReceivedHandler @Inject constructor(
                 is NotifyPaymentReceived.Command.Lightning -> true
                 is NotifyPaymentReceived.Command.Onchain -> {
                     delay(DELAY_FOR_ACTIVITY_SYNC_MS)
-                    activityRepo.shouldShowPaymentReceived(command.paymentHashOrTxId, command.sats)
+                    activityRepo.shouldShowReceivedSheet(command.paymentHashOrTxId, command.sats)
                 }
             }
 

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

@@ -33,11 +33,6 @@ fun Activity.totalValue() = when (this) {
     }
 }
 
-fun Activity.canBeBoosted() = when (this) {
-    is Activity.Onchain -> !v1.confirmed && v1.doesExist && !v1.isBoosted && !v1.isTransfer && v1.value > 0uL
-    else -> false
-}
-
 fun Activity.isBoosted() = when (this) {
     is Activity.Onchain -> v1.isBoosted
     else -> false

app/src/main/java/to/bitkit/repositories/ActivityRepo.kt

@@ -26,6 +26,7 @@ import org.lightningdevkit.ldknode.ChannelDetails
 import org.lightningdevkit.ldknode.PaymentDetails
 import org.lightningdevkit.ldknode.PaymentDirection
 import org.lightningdevkit.ldknode.PaymentKind
+import org.lightningdevkit.ldknode.TransactionDetails
 import to.bitkit.data.CacheStore
 import to.bitkit.data.dto.PendingBoostActivity
 import to.bitkit.di.BgDispatcher
@@ -36,7 +37,6 @@ import to.bitkit.ext.nowTimestamp
 import to.bitkit.ext.rawId
 import to.bitkit.models.ActivityBackupV1
 import to.bitkit.services.CoreService
-import to.bitkit.utils.AddressChecker
 import to.bitkit.utils.Logger
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -50,7 +50,6 @@ class ActivityRepo @Inject constructor(
     private val coreService: CoreService,
     private val lightningRepo: LightningRepo,
     private val blocktankRepo: BlocktankRepo,
-    private val addressChecker: AddressChecker,
     private val cacheStore: CacheStore,
     private val transferRepo: TransferRepo,
     private val clock: Clock,
@@ -83,8 +82,6 @@ class ActivityRepo @Inject constructor(
 
             isSyncingLdkNodePayments.update { true }
 
-            deletePendingActivities()
-
             lightningRepo.getPayments().mapCatching { payments ->
                 Logger.debug("Got payments with success, syncing activities", context = TAG)
                 syncLdkNodePayments(payments).getOrThrow()
@@ -167,67 +164,13 @@ class ActivityRepo @Inject constructor(
     }
 
     private suspend fun findClosedChannelForTransaction(txid: String): String? {
-        return try {
-            val closedChannelsResult = getClosedChannels(SortDirection.DESC)
-            val closedChannels = closedChannelsResult.getOrNull() ?: return null
-            if (closedChannels.isEmpty()) return null
-
-            val txDetails = addressChecker.getTransaction(txid)
-
-            txDetails.vin.firstNotNullOfOrNull { input ->
-                val inputTxid = input.txid ?: return@firstNotNullOfOrNull null
-                val inputVout = input.vout ?: return@firstNotNullOfOrNull null
-
-                closedChannels.firstOrNull { channel ->
-                    channel.fundingTxoTxid == inputTxid && channel.fundingTxoIndex == inputVout.toUInt()
-                }?.channelId
-            }
-        } catch (e: Exception) {
-            Logger.warn(
-                "Failed to check if transaction $txid spends closed channel funding UTXO",
-                e,
-                context = TAG
-            )
-            null
-        }
+        return coreService.activity.findClosedChannelForTransaction(txid, null)
     }
 
-    private suspend fun getOnchainActivityByTxId(txid: String): OnchainActivity? {
+    suspend fun getOnchainActivityByTxId(txid: String): OnchainActivity? {
         return coreService.activity.getOnchainActivityByTxId(txid)
     }
 
-    /**
-     * Determines whether to show the payment received UI for an onchain transaction.
-     * Returns false for:
-     * - Zero value transactions
-     * - Channel closure transactions (transfers to savings)
-     * - RBF replacement transactions with the same value as the original
-     */
-    suspend fun shouldShowPaymentReceived(txid: String, value: ULong): Boolean = withContext(bgDispatcher) {
-        if (value == 0uL) return@withContext false
-
-        if (findClosedChannelForTransaction(txid) != null) {
-            Logger.debug("Skipping payment received UI for channel closure tx: $txid", context = TAG)
-            return@withContext false
-        }
-
-        val onchainActivity = getOnchainActivityByTxId(txid)
-        if (onchainActivity != null && onchainActivity.boostTxIds.isNotEmpty()) {
-            for (replacedTxid in onchainActivity.boostTxIds) {
-                val replacedActivity = getOnchainActivityByTxId(replacedTxid)
-                if (replacedActivity != null && replacedActivity.value == value) {
-                    Logger.info(
-                        "Skipping payment received UI for RBF replacement $txid with same value as $replacedTxid",
-                        context = TAG
-                    )
-                    return@withContext false
-                }
-            }
-        }
-
-        return@withContext true
-    }
-
     /**
      * Checks if a transaction is inbound (received) by looking up the payment direction.
      */
@@ -247,6 +190,58 @@ class ActivityRepo @Inject constructor(
         return@withContext !onchainActivity.doesExist
     }
 
+    suspend fun handleOnchainTransactionReceived(
+        txid: String,
+        details: TransactionDetails,
+    ) {
+        coreService.activity.handleOnchainTransactionReceived(txid, details)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun handleOnchainTransactionConfirmed(
+        txid: String,
+        details: TransactionDetails,
+    ) {
+        coreService.activity.handleOnchainTransactionConfirmed(txid, details)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun handleOnchainTransactionReplaced(txid: String, conflicts: List<String>) {
+        coreService.activity.handleOnchainTransactionReplaced(txid, conflicts)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun handleOnchainTransactionReorged(txid: String) {
+        coreService.activity.handleOnchainTransactionReorged(txid)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun handleOnchainTransactionEvicted(txid: String) {
+        coreService.activity.handleOnchainTransactionEvicted(txid)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun handlePaymentEvent(paymentHash: String) {
+        coreService.activity.handlePaymentEvent(paymentHash)
+        notifyActivitiesChanged()
+    }
+
+    suspend fun shouldShowReceivedSheet(txid: String, value: ULong): Boolean {
+        return coreService.activity.shouldShowReceivedSheet(txid, value)
+    }
+
+    suspend fun getBoostTxDoesExist(boostTxIds: List<String>): Map<String, Boolean> {
+        return coreService.activity.getBoostTxDoesExist(boostTxIds)
+    }
+
+    suspend fun isCpfpChildTransaction(txId: String): Boolean {
+        return coreService.activity.isCpfpChildTransaction(txId)
+    }
+
+    suspend fun getTxIdsInBoostTxIds(): Set<String> {
+        return coreService.activity.getTxIdsInBoostTxIds()
+    }
+
     /**
      * Gets a specific activity by payment hash or txID with retry logic
      */
@@ -392,22 +387,13 @@ class ActivityRepo @Inject constructor(
         ).fold(
             onSuccess = {
                 Logger.debug(
-                    "Activity $id updated with success. new data: $activity. " +
-                        "Marking activity $activityIdToDelete as removed from mempool",
+                    "Activity $id updated with success. new data: $activity",
                     context = TAG
                 )
 
                 val tags = coreService.activity.tags(activityIdToDelete)
                 addTagsToActivity(activityId = id, tags = tags)
 
-                markActivityAsRemovedFromMempool(activityIdToDelete).onFailure { e ->
-                    Logger.warn(
-                        "Failed to mark $activityIdToDelete as removed from mempool, caching to retry on next sync",
-                        e = e,
-                        context = TAG
-                    )
-                    cacheStore.addActivityToPendingDelete(activityId = activityIdToDelete)
-                }
                 Result.success(Unit)
             },
             onFailure = { e ->
@@ -422,16 +408,6 @@ class ActivityRepo @Inject constructor(
         )
     }
 
-    private suspend fun deletePendingActivities() = withContext(bgDispatcher) {
-        cacheStore.data.first().activitiesPendingDelete.map { activityId ->
-            async {
-                markActivityAsRemovedFromMempool(activityId).onSuccess {
-                    cacheStore.removeActivityFromPendingDelete(activityId)
-                }
-            }
-        }.awaitAll()
-    }
-
     private suspend fun boostPendingActivities() = withContext(bgDispatcher) {
         cacheStore.data.first().pendingBoostActivities.map { pendingBoostActivity ->
             async {
@@ -484,32 +460,6 @@ class ActivityRepo @Inject constructor(
         }.awaitAll()
     }
 
-    /**
-     * Marks an activity as removed from mempool (sets doesExist = false).
-     * Used for RBFed transactions that are replaced.
-     */
-    private suspend fun markActivityAsRemovedFromMempool(activityId: String): Result<Unit> = withContext(bgDispatcher) {
-        return@withContext runCatching {
-            val existingActivity = getActivity(activityId).getOrNull()
-                ?: return@withContext Result.failure(Exception("Activity $activityId not found"))
-
-            if (existingActivity is Activity.Onchain) {
-                val updatedActivity = Activity.Onchain(
-                    v1 = existingActivity.v1.copy(
-                        doesExist = false,
-                        updatedAt = nowTimestamp().toEpochMilli().toULong()
-                    )
-                )
-                updateActivity(id = activityId, activity = updatedActivity, forceUpdate = true).getOrThrow()
-                notifyActivitiesChanged()
-            } else {
-                return@withContext Result.failure(Exception("Activity $activityId is not an onchain activity"))
-            }
-        }.onFailure { e ->
-            Logger.error("markActivityAsRemovedFromMempool error for ID: $activityId", e, context = TAG)
-        }
-    }
-
     /**
      * Deletes an activity
      */

app/src/main/java/to/bitkit/repositories/LightningRepo.kt

@@ -35,6 +35,7 @@ import org.lightningdevkit.ldknode.PaymentDetails
 import org.lightningdevkit.ldknode.PaymentId
 import org.lightningdevkit.ldknode.PeerDetails
 import org.lightningdevkit.ldknode.SpendableUtxo
+import org.lightningdevkit.ldknode.TransactionDetails
 import org.lightningdevkit.ldknode.Txid
 import to.bitkit.data.CacheStore
 import to.bitkit.data.SettingsStore
@@ -717,6 +718,18 @@ class LightningRepo @Inject constructor(
         Result.success(payments)
     }
 
+    suspend fun getTransactionDetails(txid: Txid): Result<TransactionDetails?> = executeWhenNodeRunning(
+        "Get transaction details by txid"
+    ) {
+        Result.success(lightningService.getTransactionDetails(txid))
+    }
+
+    suspend fun getAddressBalance(address: String): Result<ULong> = executeWhenNodeRunning("Get address balance") {
+        runCatching {
+            lightningService.getAddressBalance(address)
+        }
+    }
+
     suspend fun listSpendableOutputs(): Result<List<SpendableUtxo>> = executeWhenNodeRunning("List spendable outputs") {
         lightningService.listSpendableOutputs()
     }

app/src/main/java/to/bitkit/repositories/WalletRepo.kt

@@ -29,7 +29,6 @@ import to.bitkit.models.toDerivationPath
 import to.bitkit.services.CoreService
 import to.bitkit.usecases.DeriveBalanceStateUseCase
 import to.bitkit.usecases.WipeWalletUseCase
-import to.bitkit.utils.AddressChecker
 import to.bitkit.utils.Bip21Utils
 import to.bitkit.utils.Logger
 import to.bitkit.utils.ServiceError
@@ -43,7 +42,6 @@ class WalletRepo @Inject constructor(
     private val keychain: Keychain,
     private val coreService: CoreService,
     private val settingsStore: SettingsStore,
-    private val addressChecker: AddressChecker,
     private val lightningRepo: LightningRepo,
     private val cacheStore: CacheStore,
     private val preActivityMetadataRepo: PreActivityMetadataRepo,
@@ -83,9 +81,8 @@ class WalletRepo @Inject constructor(
 
     suspend fun checkAddressUsage(address: String): Result<Boolean> = withContext(bgDispatcher) {
         return@withContext try {
-            val addressInfo = addressChecker.getAddressInfo(address)
-            val hasTransactions = addressInfo.chain_stats.tx_count > 0 || addressInfo.mempool_stats.tx_count > 0
-            Result.success(hasTransactions)
+            val result = coreService.isAddressUsed(address)
+            Result.success(result)
         } catch (e: Exception) {
             Logger.error("checkAddressUsage error", e, context = TAG)
             Result.failure(e)