fix: decouple wallet restore from profile refresh

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

@@ -12,6 +12,7 @@ import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
+import to.bitkit.data.backup.VssClientCoordinator
 import to.bitkit.data.backup.VssStoreIdProvider
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.data.keychain.hasPendingWalletRestore
@@ -30,6 +31,7 @@ class WalletConnectionRecovery @Inject constructor(
     private val db: AppDb,
     private val storeIdProvider: VssStoreIdProvider,
     private val settingsStore: SettingsStore,
+    private val vssClients: VssClientCoordinator,
 ) {
     companion object {
         internal const val KEY = "WALLET_CONNECTION_RECOVERY"
@@ -130,7 +132,7 @@ class WalletConnectionRecovery @Inject constructor(
                 currentCoroutineContext().ensureActive()
                 beginWipe()
                 currentCoroutineContext().ensureActive()
-                block()
+                vssClients.withSuspendedClients { block() }
             } finally {
                 storeIdProvider.clearCache()
                 endWipe()

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

@@ -3,58 +3,54 @@ package to.bitkit.data.backup
 import com.synonym.vssclient.KeyVersion
 import com.synonym.vssclient.VssItem
 import com.synonym.vssclient.vssDelete
+import com.synonym.vssclient.vssDeriveStoreId
 import com.synonym.vssclient.vssGet
 import com.synonym.vssclient.vssListKeys
 import com.synonym.vssclient.vssNewClientWithLnurlAuth
 import com.synonym.vssclient.vssStore
-import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.ensureActive
 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.ext.runSuspendCatching
 import to.bitkit.utils.Logger
 import to.bitkit.utils.ServiceError
 import javax.inject.Inject
 import javax.inject.Singleton
+import kotlin.coroutines.cancellation.CancellationException
 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 coordinator: VssClientCoordinator,
     private val keychain: Keychain,
 ) {
-    @Volatile
-    private var isSetup = CompletableDeferred<Unit>()
-    private val setupMutex = Mutex()
-
     suspend fun setup(walletIndex: Int = 0): Result<Unit> = withContext(ioDispatcher) {
-        setupMutex.withLock {
-            val gate = isSetup
-            runCatching {
-                if (gate.isCompleted && !gate.isCancelled) return@runCatching
-
+        runCatching {
+            coordinator.setup(VssClientCoordinator.Domain.APP) {
                 val mnemonic = keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name)
                     ?: throw MnemonicNotAvailableException()
 
                 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.isBlank()) {
                         throw ServiceError.VssAuthRequired()
                     }
                     val passphrase = keychain.loadString(Keychain.Key.BIP39_PASSPHRASE.name)
+                    val vssStoreId = vssDeriveStoreId(Env.vssStoreIdPrefix, mnemonic, passphrase)
 
                     vssNewClientWithLnurlAuth(
                         baseUrl = vssUrl,
@@ -63,14 +59,13 @@ class VssBackupClient @Inject constructor(
                         passphrase = passphrase,
                         lnurlAuthServerUrl = lnurlAuthServerUrl,
                     )
-                    gate.complete(Unit)
-                    Logger.info("VSS client setup with server: '$vssUrl'", context = TAG)
+                    Logger.info("VSS client setup for wallet[$walletIndex] with server: '$vssUrl'", context = TAG)
                 }
-            }.onFailure {
-                gate.completeExceptionally(it)
-                if (isSetup === gate) isSetup = CompletableDeferred()
-                Logger.error("VSS client setup error", it, context = TAG)
             }
+        }.onFailure {
+            currentCoroutineContext().ensureActive()
+            if (it is CancellationException && it !is TimeoutCancellationException) throw it
+            Logger.error("VSS client setup error", it, context = TAG)
         }
     }
 
@@ -85,49 +80,43 @@ class VssBackupClient @Inject constructor(
         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)
+        coordinator.withWallet {
+            val log = SetupRetryLogger().apply(logger)
+            var attempt = 0
+            while (attempt < maxAttempts) {
+                val result = setup()
+                if (result.isSuccess) {
+                    log.onSuccess(attempt + 1)
+                    return@withWallet Result.success(Unit)
+                }
+                val exception = result.exceptionOrNull()
+                if (exception != null && exception !is MnemonicNotAvailableException) {
+                    return@withWallet result
+                }
+                attempt++
+                if (attempt < maxAttempts) {
+                    val delayMs = baseDelayMs * attempt
+                    log.onRetry(attempt, maxAttempts, delayMs)
+                    delay(delayMs)
+                }
             }
+            log.onExhausted(maxAttempts)
+            Result.failure(MnemonicNotAvailableException())
         }
-        log.onExhausted(maxAttempts)
-        Result.failure(MnemonicNotAvailableException())
-    }
-
-    fun reset() {
-        synchronized(this) {
-            isSetup.cancel()
-            isSetup = CompletableDeferred()
-        }
-        vssStoreIdProvider.clearCache()
-        Logger.debug("VSS client reset", context = TAG)
     }
 
     suspend fun putObject(
         key: String,
         data: ByteArray,
     ): Result<VssItem> = withContext(ioDispatcher) {
-        isSetup.await()
         Logger.verbose("VSS 'putObject' call for '$key'", context = TAG)
-        runCatching {
-            vssStore(
-                key = key,
-                value = data,
-            )
+        runSuspendCatching {
+            coordinator.withClient(VssClientCoordinator.Domain.APP) {
+                vssStore(
+                    key = key,
+                    value = data,
+                )
+            }
         }.onSuccess {
             Logger.verbose("VSS 'putObject' success for '$key' at version: '${it.version}'", context = TAG)
         }.onFailure {
@@ -136,12 +125,13 @@ class VssBackupClient @Inject constructor(
     }
 
     suspend fun getObject(key: String): Result<VssItem?> = withContext(ioDispatcher) {
-        isSetup.await()
         Logger.verbose("VSS 'getObject' call for '$key'", context = TAG)
-        runCatching {
-            vssGet(
-                key = key,
-            )
+        runSuspendCatching {
+            coordinator.withClient(VssClientCoordinator.Domain.APP) {
+                vssGet(
+                    key = key,
+                )
+            }
         }.onSuccess {
             if (it == null) {
                 Logger.verbose("VSS 'getObject' success null for '$key'", context = TAG)
@@ -154,10 +144,11 @@ class VssBackupClient @Inject constructor(
     }
 
     suspend fun listKeys(prefix: String? = null): Result<List<KeyVersion>> = withContext(ioDispatcher) {
-        isSetup.await()
         Logger.verbose("VSS 'listKeys' call with prefix: '$prefix'", context = TAG)
-        runCatching {
-            vssListKeys(prefix = prefix)
+        runSuspendCatching {
+            coordinator.withClient(VssClientCoordinator.Domain.APP) {
+                vssListKeys(prefix = prefix)
+            }
         }.onSuccess {
             Logger.verbose("VSS 'listKeys' success - found ${it.size} key(s)", context = TAG)
         }.onFailure {
@@ -166,10 +157,11 @@ class VssBackupClient @Inject constructor(
     }
 
     suspend fun deleteObject(key: String): Result<Boolean> = withContext(ioDispatcher) {
-        isSetup.await()
         Logger.verbose("VSS 'deleteObject' call for '$key'", context = TAG)
-        runCatching {
-            vssDelete(key = key)
+        runSuspendCatching {
+            coordinator.withClient(VssClientCoordinator.Domain.APP) {
+                vssDelete(key = key)
+            }
         }.onSuccess { wasDeleted ->
             if (wasDeleted) {
                 Logger.verbose("VSS 'deleteObject' success for '$key' - key was deleted", context = TAG)
@@ -182,16 +174,17 @@ class VssBackupClient @Inject constructor(
     }
 
     suspend fun deleteAllKeys(): Result<Int> = withContext(ioDispatcher) {
-        isSetup.await()
         Logger.verbose("VSS 'deleteAllKeys' call", context = TAG)
-        runCatching {
-            val keys = vssListKeys(prefix = null)
-            var deletedCount = 0
-            for (keyVersion in keys) {
-                val wasDeleted = vssDelete(key = keyVersion.key)
-                if (wasDeleted) deletedCount++
+        runSuspendCatching {
+            coordinator.withClient(VssClientCoordinator.Domain.APP) {
+                val keys = vssListKeys(prefix = null)
+                var deletedCount = 0
+                for (keyVersion in keys) {
+                    val wasDeleted = vssDelete(key = keyVersion.key)
+                    if (wasDeleted) deletedCount++
+                }
+                deletedCount
             }
-            deletedCount
         }.onSuccess {
             Logger.verbose("VSS 'deleteAllKeys' success - deleted $it key(s)", context = TAG)
         }.onFailure {