refactor: create the LightningRepository

Author: jvsena42

app/src/main/java/to/bitkit/di/RepositoryModule.kt

@@ -0,0 +1,35 @@
+@file:Suppress("unused")
+
+package to.bitkit.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import to.bitkit.repositories.LightningRepository
+import to.bitkit.services.LdkNodeEventBus
+import to.bitkit.services.LightningService
+import to.bitkit.utils.AddressChecker
+import javax.inject.Qualifier
+
+@Module
+@InstallIn(SingletonComponent::class)
+object RepositoryModule {
+
+    @Provides
+    fun provideLightningRepository(
+        @BgDispatcher bgDispatcher: CoroutineDispatcher,
+        lightningService: LightningService,
+        ldkNodeEventBus: LdkNodeEventBus,
+        addressChecker: AddressChecker
+    ): LightningRepository {
+        return LightningRepository(
+            bgDispatcher = bgDispatcher,
+            lightningService = lightningService,
+            ldkNodeEventBus = ldkNodeEventBus,
+            addressChecker = addressChecker
+        )
+    }
+}

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

@@ -0,0 +1,233 @@
+package to.bitkit.repositories
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
+import org.lightningdevkit.ldknode.BalanceDetails
+import org.lightningdevkit.ldknode.Bolt11Invoice
+import org.lightningdevkit.ldknode.ChannelDetails
+import org.lightningdevkit.ldknode.NodeStatus
+import org.lightningdevkit.ldknode.PaymentId
+import org.lightningdevkit.ldknode.UserChannelId
+import org.lightningdevkit.ldknode.generateEntropyMnemonic
+import to.bitkit.di.BgDispatcher
+import to.bitkit.models.LnPeer
+import to.bitkit.models.NodeLifecycleState
+import to.bitkit.services.LdkNodeEventBus
+import to.bitkit.services.LightningService
+import to.bitkit.services.NodeEventHandler
+import to.bitkit.utils.AddressChecker
+import to.bitkit.utils.Logger
+import to.bitkit.utils.ServiceError
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class LightningRepository @Inject constructor(
+    @BgDispatcher private val bgDispatcher: CoroutineDispatcher,
+    private val lightningService: LightningService,
+    private val ldkNodeEventBus: LdkNodeEventBus,
+    private val addressChecker: AddressChecker
+) {
+    private var nodeLifecycleState: NodeLifecycleState = NodeLifecycleState.Stopped
+
+    fun getNodeLifecycleState(): NodeLifecycleState = nodeLifecycleState
+
+    suspend fun setup(walletIndex: Int): Result<Unit> = withContext(bgDispatcher) {
+        return@withContext try {
+            lightningService.setup(walletIndex)
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Node setup error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun start(walletIndex: Int, eventHandler: NodeEventHandler? = null): Result<Unit> = withContext(bgDispatcher) {
+        if (nodeLifecycleState.isRunningOrStarting()) {
+            return@withContext Result.success(Unit)
+        }
+
+        try {
+            nodeLifecycleState = NodeLifecycleState.Starting
+
+            // Setup if not already setup
+            if (lightningService.node == null) {
+                val setupResult = setup(walletIndex)
+                if (setupResult.isFailure) {
+                    nodeLifecycleState = NodeLifecycleState.ErrorStarting(setupResult.exceptionOrNull() ?: Exception("Unknown setup error"))
+                    return@withContext setupResult
+                }
+            }
+
+            // Start the node service
+            lightningService.start { event ->
+                eventHandler?.invoke(event)
+                ldkNodeEventBus.emit(event)
+            }
+
+            nodeLifecycleState = NodeLifecycleState.Running
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Node start error", e)
+            nodeLifecycleState = NodeLifecycleState.ErrorStarting(e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun waitForNodeStart(timeout: Long = 30000): Result<Unit> = withContext(bgDispatcher) {
+        val startTime = System.currentTimeMillis()
+
+        while (System.currentTimeMillis() - startTime < timeout) {
+            when (nodeLifecycleState) {
+                NodeLifecycleState.Running -> return@withContext Result.success(Unit)
+                is NodeLifecycleState.ErrorStarting -> {
+                    val error = (nodeLifecycleState as NodeLifecycleState.ErrorStarting).cause
+                    return@withContext Result.failure(error)
+                }
+
+                else -> delay(100) // Wait a bit before checking again
+            }
+        }
+
+        Result.failure(ServiceError.NodeStartTimeout)
+    }
+
+    suspend fun stop(): Result<Unit> = withContext(bgDispatcher) {
+        if (nodeLifecycleState.isStoppedOrStopping()) {
+            return@withContext Result.success(Unit)
+        }
+
+        try {
+            nodeLifecycleState = NodeLifecycleState.Stopping
+            lightningService.stop()
+            nodeLifecycleState = NodeLifecycleState.Stopped
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Node stop error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun sync(): Result<Unit> = withContext(bgDispatcher) {
+        try {
+            lightningService.sync()
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Sync error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun wipeStorage(walletIndex: Int): Result<Unit> = withContext(bgDispatcher) {
+        try {
+            lightningService.wipeStorage(walletIndex)
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Wipe storage error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun connectToTrustedPeers(): Result<Unit> = withContext(bgDispatcher) {
+        try {
+            lightningService.connectToTrustedPeers()
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Connect to trusted peers error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun disconnectPeer(peer: LnPeer): Result<Unit> = withContext(bgDispatcher) {
+        try {
+            lightningService.disconnectPeer(peer)
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Disconnect peer error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun newAddress(): Result<String> = withContext(bgDispatcher) {
+        try {
+            val address = lightningService.newAddress()
+            Result.success(address)
+        } catch (e: Throwable) {
+            Logger.error("New address error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun checkAddressUsage(address: String): Result<Boolean> = withContext(bgDispatcher) {
+        try {
+            val addressInfo = addressChecker.getAddressInfo(address)
+            val hasTransactions = addressInfo.chain_stats.tx_count > 0 || addressInfo.mempool_stats.tx_count > 0
+            Result.success(hasTransactions)
+        } catch (e: Throwable) {
+            Logger.error("Check address usage error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun createInvoice(
+        amountSats: ULong? = null,
+        description: String,
+        expirySeconds: UInt = 86_400u
+    ): Result<Bolt11Invoice> = withContext(bgDispatcher) {
+        try {
+            val invoice = lightningService.receive(amountSats, description, expirySeconds)
+            Result.success(invoice)
+        } catch (e: Throwable) {
+            Logger.error("Create invoice error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun payInvoice(bolt11: String): Result<PaymentId> = withContext(bgDispatcher) {
+        try {
+            val paymentId = lightningService.send(bolt11)
+            Result.success(paymentId)
+        } catch (e: Throwable) {
+            Logger.error("Pay invoice error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun openChannel(
+        peer: LnPeer,
+        channelAmountSats: ULong,
+        pushToCounterpartySats: ULong? = null
+    ): Result<UserChannelId> = withContext(bgDispatcher) {
+        try {
+            val result = lightningService.openChannel(peer, channelAmountSats, pushToCounterpartySats)
+            result
+        } catch (e: Throwable) {
+            Logger.error("Open channel error", e)
+            Result.failure(e)
+        }
+    }
+
+    suspend fun closeChannel(userChannelId: String, counterpartyNodeId: String): Result<Unit> = withContext(bgDispatcher) {
+        try {
+            lightningService.closeChannel(userChannelId, counterpartyNodeId)
+            Result.success(Unit)
+        } catch (e: Throwable) {
+            Logger.error("Close channel error", e)
+            Result.failure(e)
+        }
+    }
+
+    fun getSyncFlow(): Flow<Unit> = lightningService.syncFlow()
+
+    fun getNodeId(): String? = lightningService.nodeId
+    fun getBalances(): BalanceDetails? = lightningService.balances
+    fun getStatus(): NodeStatus? = lightningService.status
+    fun getPeers(): List<LnPeer>? = lightningService.peers
+    fun getChannels(): List<ChannelDetails>? = lightningService.channels
+
+    fun hasChannels(): Boolean = lightningService.channels?.isNotEmpty() == true
+
+    fun generateMnemonic(): String = generateEntropyMnemonic()
+}

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

@@ -23,6 +23,7 @@ open class AppError(override val message: String? = null) : Exception(message) {
 sealed class ServiceError(message: String) : AppError(message) {
     data object NodeNotSetup : ServiceError("Node is not setup")
     data object NodeNotStarted : ServiceError("Node is not started")
+    data object NodeStartTimeout : ServiceError("Node took too long to start")
     class LdkNodeSqliteAlreadyExists(path: String) : ServiceError("LDK-node SQLite file already exists at $path")
     data object LdkToLdkNodeMigration : ServiceError("LDK to LDK-node migration issue")
     data object MnemonicNotFound : ServiceError("Mnemonic not found")