refactor: simplify setup return types to Result<Unit>

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ovitrif

app/src/main/java/to/bitkit/data/backup/VssBackupClient.kt

@@ -21,6 +21,8 @@ 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,
@@ -29,14 +31,14 @@ class VssBackupClient @Inject constructor(
 ) {
     private var isSetup = CompletableDeferred<Unit>()
 
-    suspend fun setup(walletIndex: Int = 0): Result<Boolean> = withContext(ioDispatcher) {
+    suspend fun setup(walletIndex: Int = 0): Result<Unit> = withContext(ioDispatcher) {
         runCatching {
             if (isSetup.isCompleted && !isSetup.isCancelled) {
-                runCatching { isSetup.await() }.onSuccess { return@runCatching true }
+                runCatching { isSetup.await() }.onSuccess { return@runCatching }
             }
 
             val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)
-                ?: return@runCatching false
+                ?: throw MnemonicNotAvailableException()
 
             withTimeout(30.seconds) {
                 Logger.debug("VSS client setting up…", context = TAG)
@@ -64,7 +66,6 @@ class VssBackupClient @Inject constructor(
                 isSetup.complete(Unit)
                 Logger.info("VSS client setup with server: '$vssUrl'", context = TAG)
             }
-            true
         }.onFailure {
             isSetup.completeExceptionally(it)
             Logger.error("VSS client setup error", it, context = TAG)
@@ -81,16 +82,17 @@ class VssBackupClient @Inject constructor(
         maxAttempts: Int = 10,
         baseDelayMs: Long = 1000L,
         logger: SetupRetryLogger.() -> Unit,
-    ): Result<Boolean> = withContext(ioDispatcher) {
+    ): Result<Unit> = withContext(ioDispatcher) {
         val log = SetupRetryLogger().apply(logger)
         var attempt = 0
         while (attempt < maxAttempts) {
             val result = setup()
-            if (result.getOrDefault(false)) {
+            if (result.isSuccess) {
                 log.onSuccess(attempt + 1)
-                return@withContext Result.success(true)
+                return@withContext Result.success(Unit)
             }
-            if (result.isFailure) {
+            val exception = result.exceptionOrNull()
+            if (exception != null && exception !is MnemonicNotAvailableException) {
                 return@withContext result
             }
             attempt++
@@ -101,7 +103,7 @@ class VssBackupClient @Inject constructor(
             }
         }
         log.onExhausted(maxAttempts)
-        Result.success(false)
+        Result.failure(MnemonicNotAvailableException())
     }
 
     fun reset() {

app/src/test/java/to/bitkit/data/backup/VssBackupClientTest.kt

@@ -10,7 +10,8 @@ import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.test.BaseUnitTest
-import kotlin.test.assertFalse
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
 
 class VssBackupClientTest : BaseUnitTest() {
 
@@ -29,12 +30,13 @@ class VssBackupClientTest : BaseUnitTest() {
     }
 
     @Test
-    fun `setup returns false when mnemonic is not available`() = 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()
 
-        assertFalse(result.getOrThrow())
+        assertTrue(result.isFailure)
+        assertIs<MnemonicNotAvailableException>(result.exceptionOrNull())
     }
 
     @Test
@@ -63,9 +65,9 @@ class VssBackupClientTest : BaseUnitTest() {
     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 return false without crashing
-        assertFalse(sut.setup().getOrThrow())
-        assertFalse(sut.setup().getOrThrow())
-        assertFalse(sut.setup().getOrThrow())
+        // Multiple calls should all fail with MnemonicNotAvailableException without crashing
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
+        assertIs<MnemonicNotAvailableException>(sut.setup().exceptionOrNull())
     }
 }