Merge branch 'master' into fix/dismissable-foreground-notification

jvsena42 · web-flow · commit fa7e0f2f151a · 2026-01-21T10:21:34.000-03:00
diff --git a/AGENTS.md b/AGENTS.md
@@ -147,9 +147,9 @@ fun updateState(action: Action) {
 ```kotlin
 suspend fun getData(): Result<Data> = withContext(Dispatchers.IO) {
   runCatching {
-    Result.success(apiService.fetchData())
-  }.onFailure { e ->
-    Logger.error("Failed", e = e, context = TAG)
+    apiService.fetchData()
+  }.onFailure {
+    Logger.error("Failed", it, context = TAG)
   }
 }
 ```
@@ -176,6 +176,7 @@ suspend fun getData(): Result<Data> = withContext(Dispatchers.IO) {
 - ALWAYS acknowledge datastore async operations run synchronously in a suspend context
 - NEVER use `runBlocking` in suspend functions
 - ALWAYS pass the TAG as context to `Logger` calls, e.g. `Logger.debug("message", context = TAG)`
+- NEVER add `e = ` named parameter to Logger calls
 - ALWAYS log errors at the final handling layer where the error is acted upon, not in intermediate layers that just propagate it
 - ALWAYS use the Result API instead of try-catch
 - NEVER wrap methods returning `Result<T>` in try-catch
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -47,8 +47,8 @@ android {
         applicationId = "to.bitkit"
         minSdk = 28
         targetSdk = 36
-        versionCode = 169
-        versionName = "2.0.0-rc.3"
+        versionCode = 170
+        versionName = "2.0.0-rc.4"
         testInstrumentationRunner = "to.bitkit.test.HiltTestRunner"
         vectorDrawables {
             useSupportLibrary = true
diff --git a/app/src/main/java/to/bitkit/data/backup/VssBackupClient.kt b/app/src/main/java/to/bitkit/data/backup/VssBackupClient.kt
@@ -10,59 +10,105 @@ import com.synonym.vssclient.vssNewClientWithLnurlAuth
 import com.synonym.vssclient.vssStore
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import kotlinx.coroutines.withTimeout
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.di.IoDispatcher
 import to.bitkit.env.Env
 import to.bitkit.utils.Logger
-import to.bitkit.utils.ServiceError
 import javax.inject.Inject
 import javax.inject.Singleton
 import kotlin.time.Duration.Companion.seconds
 
+class MnemonicNotAvailableException : Exception("Mnemonic not available")
+
 @Singleton
 class VssBackupClient @Inject constructor(
     @IoDispatcher private val ioDispatcher: CoroutineDispatcher,
     private val vssStoreIdProvider: VssStoreIdProvider,
     private val keychain: Keychain,
 ) {
     private var isSetup = CompletableDeferred<Unit>()
+    private val setupMutex = Mutex()
 
-    suspend fun setup(walletIndex: Int = 0) = withContext(ioDispatcher) {
-        runCatching {
-            withTimeout(30.seconds) {
-                Logger.debug("VSS client setting up…", context = TAG)
-                val vssUrl = Env.vssServerUrl
-                val lnurlAuthServerUrl = Env.lnurlAuthServerUrl
-                val vssStoreId = vssStoreIdProvider.getVssStoreId(walletIndex)
-                Logger.verbose("Building VSS client with vssUrl: '$vssUrl'", context = TAG)
-                Logger.verbose("Building VSS client with lnurlAuthServerUrl: '$lnurlAuthServerUrl'", context = TAG)
-                if (lnurlAuthServerUrl.isNotEmpty()) {
-                    val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)
-                        ?: throw ServiceError.MnemonicNotFound()
-                    val passphrase = keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name)
+    suspend fun setup(walletIndex: Int = 0): Result<Unit> = withContext(ioDispatcher) {
+        setupMutex.withLock {
+            runCatching {
+                if (isSetup.isCompleted && !isSetup.isCancelled) {
+                    runCatching { isSetup.await() }.onSuccess { return@runCatching }
+                }
+
+                val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)
+                    ?: throw MnemonicNotAvailableException()
 
-                    vssNewClientWithLnurlAuth(
-                        baseUrl = vssUrl,
-                        storeId = vssStoreId,
-                        mnemonic = mnemonic,
-                        passphrase = passphrase,
-                        lnurlAuthServerUrl = lnurlAuthServerUrl,
-                    )
-                } else {
-                    vssNewClient(
-                        baseUrl = vssUrl,
-                        storeId = vssStoreId,
-                    )
+                withTimeout(30.seconds) {
+                    Logger.debug("VSS client setting up…", context = TAG)
+                    val vssUrl = Env.vssServerUrl
+                    val lnurlAuthServerUrl = Env.lnurlAuthServerUrl
+                    val vssStoreId = vssStoreIdProvider.getVssStoreId(walletIndex)
+                    Logger.verbose("Building VSS client with vssUrl: '$vssUrl'", context = TAG)
+                    Logger.verbose("Building VSS client with lnurlAuthServerUrl: '$lnurlAuthServerUrl'", context = TAG)
+                    if (lnurlAuthServerUrl.isNotEmpty()) {
+                        val passphrase = keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name)
+
+                        vssNewClientWithLnurlAuth(
+                            baseUrl = vssUrl,
+                            storeId = vssStoreId,
+                            mnemonic = mnemonic,
+                            passphrase = passphrase,
+                            lnurlAuthServerUrl = lnurlAuthServerUrl,
+                        )
+                    } else {
+                        vssNewClient(
+                            baseUrl = vssUrl,
+                            storeId = vssStoreId,
+                        )
+                    }
+                    isSetup.complete(Unit)
+                    Logger.info("VSS client setup with server: '$vssUrl'", context = TAG)
                 }
-                isSetup.complete(Unit)
-                Logger.info("VSS client setup with server: '$vssUrl'", context = TAG)
+            }.onFailure {
+                isSetup.completeExceptionally(it)
+                Logger.error("VSS client setup error", it, context = TAG)
+            }
+        }
+    }
+
+    class SetupRetryLogger {
+        var onSuccess: (attempt: Int) -> Unit = {}
+        var onRetry: (attempt: Int, maxAttempts: Int, delayMs: Long) -> Unit = { _, _, _ -> }
+        var onExhausted: (maxAttempts: Int) -> Unit = {}
+    }
+
+    suspend fun setupWithRetry(
+        maxAttempts: Int = 10,
+        baseDelayMs: Long = 1000L,
+        logger: SetupRetryLogger.() -> Unit,
+    ): Result<Unit> = withContext(ioDispatcher) {
+        val log = SetupRetryLogger().apply(logger)
+        var attempt = 0
+        while (attempt < maxAttempts) {
+            val result = setup()
+            if (result.isSuccess) {
+                log.onSuccess(attempt + 1)
+                return@withContext Result.success(Unit)
+            }
+            val exception = result.exceptionOrNull()
+            if (exception != null && exception !is MnemonicNotAvailableException) {
+                return@withContext result
+            }
+            attempt++
+            if (attempt < maxAttempts) {
+                val delayMs = baseDelayMs * attempt
+                log.onRetry(attempt, maxAttempts, delayMs)
+                delay(delayMs)
             }
-        }.onFailure {
-            isSetup.completeExceptionally(it)
-            Logger.error("VSS client setup error", e = it, context = TAG)
         }
+        log.onExhausted(maxAttempts)
+        Result.failure(MnemonicNotAvailableException())
     }
 
     fun reset() {
diff --git a/app/src/main/java/to/bitkit/env/Env.kt b/app/src/main/java/to/bitkit/env/Env.kt
@@ -53,7 +53,7 @@ internal object Env {
         get() {
             val isE2eLocal = isE2eTest && e2eBackend == "local"
             return when (network) {
-                Network.BITCOIN -> ElectrumServers.MAINNET.FULCRUM
+                Network.BITCOIN -> ElectrumServers.MAINNET.ESPLORA
                 Network.REGTEST -> if (isE2eLocal) ElectrumServers.REGTEST.LOCAL else ElectrumServers.REGTEST.STAG
                 Network.TESTNET -> ElectrumServers.TESTNET
                 else -> TODO("${network.name} network not implemented")
@@ -211,11 +211,11 @@ object Peers {
 
 private object ElectrumServers {
     object MAINNET {
-        const val FULCRUM = "ssl://fulcrum.bitkit.blocktank.to:8900"
+        const val ESPLORA = "ssl://bitkit.to:9999"
     }
 
     object REGTEST {
-        const val STAG = "tcp://34.65.252.32:18483"
+        const val STAG = "ssl://electrs.bitkit.stag0.blocktank.to:9999"
         const val LOCAL = "tcp://127.0.0.1:60001"
     }
 
diff --git a/app/src/main/java/to/bitkit/repositories/BackupRepo.kt b/app/src/main/java/to/bitkit/repositories/BackupRepo.kt
@@ -120,7 +120,22 @@ class BackupRepo @Inject constructor(
         isObserving = true
         Logger.debug("Start observing backup statuses and data store changes", context = TAG)
 
-        scope.launch { vssBackupClient.setup() }
+        scope.launch {
+            vssBackupClient.setupWithRetry {
+                onSuccess = { attempt ->
+                    Logger.debug("VSS client setup succeeded on attempt $attempt", context = TAG)
+                }
+                onRetry = { attempt, maxAttempts, delayMs ->
+                    Logger.debug(
+                        "VSS client setup deferred, retrying in ${delayMs}ms (attempt $attempt/$maxAttempts)",
+                        context = TAG,
+                    )
+                }
+                onExhausted = { maxAttempts ->
+                    Logger.warn("VSS client setup failed after $maxAttempts attempts", context = TAG)
+                }
+            }
+        }
 
         scope.launch {
             BackupCategory.entries.forEach { category ->
@@ -543,7 +558,7 @@ class BackupRepo @Inject constructor(
     suspend fun getLatestBackupTime(): ULong? = withContext(ioDispatcher) {
         runCatching {
             withTimeout(VSS_TIMESTAMP_TIMEOUT) {
-                vssBackupClient.setup()
+                vssBackupClient.setup().getOrThrow()
                 coroutineScope {
                     BackupCategory.entries
                         .filter { it != BackupCategory.LIGHTNING_CONNECTIONS }
diff --git a/app/src/test/java/to/bitkit/data/backup/VssBackupClientTest.kt b/app/src/test/java/to/bitkit/data/backup/VssBackupClientTest.kt
@@ -0,0 +1,73 @@
+package to.bitkit.data.backup
+
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import to.bitkit.data.keychain.Keychain
+import to.bitkit.test.BaseUnitTest
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+
+class VssBackupClientTest : BaseUnitTest() {
+
+    private lateinit var sut: VssBackupClient
+
+    private val vssStoreIdProvider = mock<VssStoreIdProvider>()
+    private val keychain = mock<Keychain>()
+
+    @Before
+    fun setUp() = runBlocking {
+        sut = VssBackupClient(
+            ioDispatcher = testDispatcher,
+            vssStoreIdProvider = vssStoreIdProvider,
+            keychain = keychain,
+        )
+    }
+
+    @Test
+    fun `setup fails with MnemonicNotAvailableException when mnemonic is not available`() = test {
+        whenever(keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)).thenReturn(null)
+
+        val result = sut.setup()
+
+        assertTrue(result.isFailure)
+        assertIs<MnemonicNotAvailableException>(result.exceptionOrNull())
+    }
+
+    @Test
+    fun `setup does not call vssStoreIdProvider when mnemonic is not available`() = test {
+        whenever(keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)).thenReturn(null)
+
+        sut.setup()
+
+        verify(vssStoreIdProvider, never()).getVssStoreId(any())
+    }
+
+    @Test
+    fun `setup checks mnemonic before proceeding with vss initialization`() = test {
+        val testMnemonic = "abandon abandon abandon abandon abandon abandon " +
+            "abandon abandon abandon abandon abandon about"
+        whenever(keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)).thenReturn(testMnemonic)
+        whenever(vssStoreIdProvider.getVssStoreId(any())).thenReturn("test-store-id")
+
+        // Setup will fail on native VSS calls, but we verify we passed the mnemonic check
+        runCatching { sut.setup() }
+
+        verify(vssStoreIdProvider).getVssStoreId(any())
+    }
+
+    @Test
+    fun `setup can be called multiple times when mnemonic not available`() = test {
+        whenever(keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)).thenReturn(null)
+
+        // Multiple calls should all fail with MnemonicNotAvailableException without crashing
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
+    }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -58,7 +58,7 @@ ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-logging = { module = "io.ktor:ktor-client-logging", version.ref = "ktor" }
 ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
-ldk-node-android = { module = "com.github.synonymdev:ldk-node", version = "v0.7.0-rc.6" } # fork | local: remove `v`
+ldk-node-android = { module = "com.github.synonymdev:ldk-node", version = "v0.7.0-rc.8" } # fork | local: remove `v`
 lifecycle-process = { group = "androidx.lifecycle", name = "lifecycle-process", version.ref = "lifecycle" }
 lifecycle-runtime-compose = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "lifecycle" }
 lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "lifecycle" }
