refactor: expose node events from LightningRepo

ovitrif · ovitrif · commit a48f42e4d98e · 2025-12-02T19:17:30.000+01:00
diff --git a/app/src/main/java/to/bitkit/androidServices/LightningNodeService.kt b/app/src/main/java/to/bitkit/androidServices/LightningNodeService.kt
@@ -7,22 +7,22 @@ import android.content.Intent
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import org.lightningdevkit.ldknode.Event
 import to.bitkit.App
 import to.bitkit.R
 import to.bitkit.data.CacheStore
+import to.bitkit.di.UiDispatcher
 import to.bitkit.domain.commands.NotifyPaymentReceived
 import to.bitkit.domain.commands.NotifyPaymentReceivedHandler
 import to.bitkit.models.NewTransactionSheetDetails
 import to.bitkit.models.NotificationDetails
 import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.WalletRepo
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.ui.MainActivity
 import to.bitkit.ui.pushNotification
 import to.bitkit.utils.Logger
@@ -31,17 +31,18 @@ import javax.inject.Inject
 @AndroidEntryPoint
 class LightningNodeService : Service() {
 
-    private val serviceScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
+    @Inject
+    @UiDispatcher
+    lateinit var uiDispatcher: CoroutineDispatcher
+
+    private val serviceScope by lazy { CoroutineScope(SupervisorJob() + uiDispatcher) }
 
     @Inject
     lateinit var lightningRepo: LightningRepo
 
     @Inject
     lateinit var walletRepo: WalletRepo
 
-    @Inject
-    lateinit var ldkNodeEventBus: LdkNodeEventBus
-
     @Inject
     lateinit var notifyPaymentReceivedHandler: NotifyPaymentReceivedHandler
 
@@ -56,26 +57,24 @@ class LightningNodeService : Service() {
 
     private fun setupService() {
         serviceScope.launch {
-            launch {
-                lightningRepo.start(
-                    eventHandler = { event ->
-                        walletRepo.refreshBip21ForEvent(event)
-                        handlePaymentReceived(event)
-                    }
-                ).onSuccess {
-                    val notification = createNotification()
-                    startForeground(NOTIFICATION_ID, notification)
-
-                    walletRepo.setWalletExistsState()
-                    walletRepo.refreshBip21()
-                    walletRepo.syncBalances()
+            lightningRepo.start(
+                eventHandler = { event ->
+                    Logger.debug("LDK-node event received in $TAG: $event", context = TAG)
+                    handlePaymentReceived(event)
                 }
+            ).onSuccess {
+                val notification = createNotification()
+                startForeground(NOTIFICATION_ID, notification)
+
+                walletRepo.setWalletExistsState()
+                walletRepo.refreshBip21()
+                walletRepo.syncBalances()
             }
         }
     }
 
     private suspend fun handlePaymentReceived(event: Event) {
-        if (event !in listOf(Event.PaymentReceived, Event.OnchainTransactionReceived)) return
+        if (event !is Event.PaymentReceived && event !is Event.OnchainTransactionReceived) return
         val command = NotifyPaymentReceived.Command.from(event, includeNotification = true) ?: return
 
         notifyPaymentReceivedHandler(command).onSuccess { result ->
diff --git a/app/src/main/java/to/bitkit/domain/commands/NotifyPaymentReceived.kt b/app/src/main/java/to/bitkit/domain/commands/NotifyPaymentReceived.kt
@@ -3,7 +3,6 @@ package to.bitkit.domain.commands
 import org.lightningdevkit.ldknode.Event
 import to.bitkit.models.NewTransactionSheetDetails
 import to.bitkit.models.NotificationDetails
-import to.bitkit.utils.Logger
 
 sealed interface NotifyPaymentReceived {
 
diff --git a/app/src/main/java/to/bitkit/domain/commands/NotifyPaymentReceivedHandler.kt b/app/src/main/java/to/bitkit/domain/commands/NotifyPaymentReceivedHandler.kt
@@ -41,7 +41,10 @@ class NotifyPaymentReceivedHandler @Inject constructor(
                     activityRepo.handleOnchainTransactionReceived(command.event.txid, command.event.details)
                     if (command.event.details.amountSats > 0) {
                         delay(DELAY_FOR_ACTIVITY_SYNC_MS)
-                        activityRepo.shouldShowReceivedSheet(command.event.txid, command.event.details.amountSats.toULong())
+                        activityRepo.shouldShowReceivedSheet(
+                            command.event.txid,
+                            command.event.details.amountSats.toULong()
+                        )
                     } else {
                         false
                     }
diff --git a/app/src/main/java/to/bitkit/repositories/LightningRepo.kt b/app/src/main/java/to/bitkit/repositories/LightningRepo.kt
@@ -14,7 +14,9 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
@@ -51,7 +53,6 @@ import to.bitkit.models.TransactionSpeed
 import to.bitkit.models.toCoinSelectAlgorithm
 import to.bitkit.models.toCoreNetwork
 import to.bitkit.services.CoreService
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.services.LightningService
 import to.bitkit.services.LnurlChannelResponse
 import to.bitkit.services.LnurlService
@@ -73,7 +74,6 @@ import kotlin.time.Duration.Companion.seconds
 class LightningRepo @Inject constructor(
     @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
     private val lightningService: LightningService,
-    private val ldkNodeEventBus: LdkNodeEventBus,
     private val settingsStore: SettingsStore,
     private val coreService: CoreService,
     private val lspNotificationsService: LspNotificationsService,
@@ -86,6 +86,9 @@ class LightningRepo @Inject constructor(
     private val _lightningState = MutableStateFlow(LightningState())
     val lightningState = _lightningState.asStateFlow()
 
+    private val _nodeEvents = MutableSharedFlow<Event>(extraBufferCapacity = 64)
+    val nodeEvents = _nodeEvents.asSharedFlow()
+
     private val scope = CoroutineScope(bgDispatcher + SupervisorJob())
 
     private var _eventHandler: NodeEventHandler? = null
@@ -263,7 +266,7 @@ class LightningRepo @Inject constructor(
     private suspend fun onEvent(event: Event) {
         handleLdkEvent(event)
         _eventHandler?.invoke(event)
-        ldkNodeEventBus.emit(event)
+        _nodeEvents.emit(event)
     }
 
     fun setRecoveryMode(enabled: Boolean) {
diff --git a/app/src/main/java/to/bitkit/repositories/WalletRepo.kt b/app/src/main/java/to/bitkit/repositories/WalletRepo.kt
@@ -56,6 +56,15 @@ class WalletRepo @Inject constructor(
     private val _balanceState = MutableStateFlow(BalanceState())
     val balanceState = _balanceState.asStateFlow()
 
+    init {
+        repoScope.launch {
+            lightningRepo.nodeEvents.collect { event ->
+                if (!walletExists()) return@collect
+                refreshBip21ForEvent(event)
+            }
+        }
+    }
+
     fun loadFromCache() {
         // TODO try keeping in sync with cache if performant and reliable
         repoScope.launch {
@@ -151,6 +160,8 @@ class WalletRepo @Inject constructor(
     }
 
     suspend fun observeLdkWallet() = withContext(bgDispatcher) {
+        // TODO:Refactor: when a sync event is emitted by ldk-node, do the sync, and
+        //  get rid of the entire polling mechanism.
         lightningRepo.getSyncFlow()
             .collect {
                 runCatching {
@@ -189,6 +200,7 @@ class WalletRepo @Inject constructor(
         when (event) {
             is Event.ChannelReady -> {
                 // Only refresh bolt11 if we can now receive on lightning
+                Logger.debug("refreshBip21ForEvent: $event", context = TAG)
                 if (lightningRepo.canReceive()) {
                     lightningRepo.createInvoice(
                         amountSats = _walletState.value.bip21AmountSats,
@@ -202,14 +214,16 @@ class WalletRepo @Inject constructor(
 
             is Event.ChannelClosed -> {
                 // Clear bolt11 if we can no longer receive on lightning
+                Logger.debug("refreshBip21ForEvent: $event", context = TAG)
                 if (!lightningRepo.canReceive()) {
                     setBolt11("")
                     updateBip21Url()
                 }
             }
 
-            is Event.PaymentReceived -> {
+            is Event.PaymentReceived, is Event.OnchainTransactionReceived -> {
                 // Check if onchain address was used, generate new one if needed
+                Logger.debug("refreshBip21ForEvent: $event", context = TAG)
                 refreshAddressIfNeeded()
                 updateBip21Url()
             }
diff --git a/app/src/main/java/to/bitkit/services/LdkNodeEventBus.kt b/app/src/main/java/to/bitkit/services/LdkNodeEventBus.kt
diff --git a/app/src/main/java/to/bitkit/ui/screens/transfer/external/ExternalNodeViewModel.kt b/app/src/main/java/to/bitkit/ui/screens/transfer/external/ExternalNodeViewModel.kt
@@ -27,7 +27,6 @@ import to.bitkit.models.formatToModernDisplay
 import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.PreActivityMetadataRepo
 import to.bitkit.repositories.WalletRepo
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.ui.screens.transfer.external.ExternalNodeContract.SideEffect
 import to.bitkit.ui.screens.transfer.external.ExternalNodeContract.UiState
 import to.bitkit.ui.shared.toast.ToastEventBus
@@ -38,7 +37,6 @@ import javax.inject.Inject
 @HiltViewModel
 class ExternalNodeViewModel @Inject constructor(
     @ApplicationContext private val context: Context,
-    private val ldkNodeEventBus: LdkNodeEventBus,
     private val walletRepo: WalletRepo,
     private val lightningRepo: LightningRepo,
     private val settingsStore: SettingsStore,
@@ -210,7 +208,7 @@ class ExternalNodeViewModel @Inject constructor(
     }
 
     private suspend fun awaitChannelPendingEvent(userChannelId: UserChannelId): Result<Event.ChannelPending> {
-        return ldkNodeEventBus.events.watchUntil { event ->
+        return lightningRepo.nodeEvents.watchUntil { event ->
             when (event) {
                 is Event.ChannelClosed -> if (event.userChannelId == userChannelId) {
                     WatchResult.Complete(Result.failure(Exception("${event.reason}")))
diff --git a/app/src/main/java/to/bitkit/ui/settings/lightning/LightningConnectionsViewModel.kt b/app/src/main/java/to/bitkit/ui/settings/lightning/LightningConnectionsViewModel.kt
@@ -37,7 +37,6 @@ import to.bitkit.repositories.BlocktankRepo
 import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.LogsRepo
 import to.bitkit.repositories.WalletRepo
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.ui.shared.toast.ToastEventBus
 import to.bitkit.utils.Logger
 import javax.inject.Inject
@@ -50,7 +49,6 @@ class LightningConnectionsViewModel @Inject constructor(
     private val lightningRepo: LightningRepo,
     internal val blocktankRepo: BlocktankRepo,
     private val logsRepo: LogsRepo,
-    private val ldkNodeEventBus: LdkNodeEventBus,
     private val walletRepo: WalletRepo,
     private val activityRepo: ActivityRepo,
 ) : ViewModel() {
@@ -129,7 +127,7 @@ class LightningConnectionsViewModel @Inject constructor(
 
     private fun observeLdkEvents() {
         viewModelScope.launch {
-            ldkNodeEventBus.events.collect { event ->
+            lightningRepo.nodeEvents.collect { event ->
                 if (event is Event.ChannelPending || event is Event.ChannelReady || event is Event.ChannelClosed) {
                     Logger.debug("Channel event received: ${event::class.simpleName}, triggering refresh")
                     refreshObservedState()
diff --git a/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/AppViewModel.kt
@@ -94,7 +94,6 @@ import to.bitkit.repositories.LightningRepo
 import to.bitkit.repositories.PreActivityMetadataRepo
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.services.AppUpdaterService
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.ui.Routes
 import to.bitkit.ui.components.Sheet
 import to.bitkit.ui.components.TimedSheetType
@@ -116,7 +115,6 @@ class AppViewModel @Inject constructor(
     private val lightningRepo: LightningRepo,
     private val walletRepo: WalletRepo,
     private val backupRepo: BackupRepo,
-    private val ldkNodeEventBus: LdkNodeEventBus,
     private val settingsStore: SettingsStore,
     private val currencyRepo: CurrencyRepo,
     private val activityRepo: ActivityRepo,
@@ -227,9 +225,10 @@ class AppViewModel @Inject constructor(
     @Suppress("CyclomaticComplexMethod")
     private fun observeLdkNodeEvents() {
         viewModelScope.launch {
-            ldkNodeEventBus.events.collect { event ->
+            lightningRepo.nodeEvents.collect { event ->
                 if (!walletRepo.walletExists()) return@collect
-
+                Logger.debug("LDK-node event received in $TAG: $event", context = TAG)
+                // TODO maybe use launch
                 runCatching {
                     when (event) {
                         is Event.BalanceChanged -> handleBalanceChanged()
@@ -1112,6 +1111,7 @@ class AppViewModel @Inject constructor(
                             )
                         )
                         lightningRepo.sync()
+                        activityRepo.syncActivities()
                     }.onFailure { e ->
                         Logger.error(msg = "Error sending onchain payment", e = e, context = TAG)
                         toast(
@@ -1291,7 +1291,7 @@ class AppViewModel @Inject constructor(
     ): Result<PaymentId> {
         return lightningRepo.payInvoice(bolt11 = bolt11, sats = amount).onSuccess { hash ->
             // Wait until matching payment event is received
-            val result = ldkNodeEventBus.events.watchUntil { event ->
+            val result = lightningRepo.nodeEvents.watchUntil { event ->
                 when (event) {
                     is Event.PaymentSuccessful -> {
                         if (event.paymentHash == hash) {
diff --git a/app/src/main/java/to/bitkit/viewmodels/QuickPayViewModel.kt b/app/src/main/java/to/bitkit/viewmodels/QuickPayViewModel.kt
@@ -12,14 +12,12 @@ import org.lightningdevkit.ldknode.PaymentId
 import to.bitkit.ext.WatchResult
 import to.bitkit.ext.watchUntil
 import to.bitkit.repositories.LightningRepo
-import to.bitkit.services.LdkNodeEventBus
 import to.bitkit.utils.Logger
 import javax.inject.Inject
 
 @HiltViewModel
 class QuickPayViewModel @Inject constructor(
     private val lightningRepo: LightningRepo,
-    private val ldkNodeEventBus: LdkNodeEventBus,
 ) : ViewModel() {
 
     private val _uiState = MutableStateFlow(QuickPayUiState())
@@ -80,7 +78,7 @@ class QuickPayViewModel @Inject constructor(
             .getOrDefault("")
 
         // Wait until matching payment event is received
-        val result = ldkNodeEventBus.events.watchUntil { event ->
+        val result = lightningRepo.nodeEvents.watchUntil { event ->
             when (event) {
                 is Event.PaymentSuccessful -> {
                     if (event.paymentHash == hash) {
diff --git a/app/src/test/java/to/bitkit/androidServices/LightningNodeServiceTest.kt b/app/src/test/java/to/bitkit/androidServices/LightningNodeServiceTest.kt
diff --git a/app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt b/app/src/test/java/to/bitkit/repositories/LightningRepoTest.kt
diff --git a/app/src/test/java/to/bitkit/repositories/WalletRepoTest.kt b/app/src/test/java/to/bitkit/repositories/WalletRepoTest.kt
