KeysBackup: Better handling of 404 to avoid error log

changelog.d/5703.sdk

@@ -0,0 +1 @@
+KeysBackupService.getCurrentVersion takes a new type `KeysBackupLastVersionResult` in the callback.

matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/keysbackup/KeysBackupTest.kt

@@ -39,10 +39,11 @@ import org.matrix.android.sdk.common.TestConstants
 import org.matrix.android.sdk.common.TestMatrixCallback
 import org.matrix.android.sdk.internal.crypto.MXCRYPTO_ALGORITHM_MEGOLM_BACKUP
 import org.matrix.android.sdk.internal.crypto.crosssigning.DeviceTrustLevel
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupVersionTrust
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion
-import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.model.ImportRoomKeysResult
 import java.util.Collections
 import java.util.concurrent.CountDownLatch
@@ -403,9 +404,9 @@ class KeysBackupTest : InstrumentedTest {
         assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled)
 
         // - Retrieve the last version from the server
-        val keysVersionResult = testHelper.doSync<KeysVersionResult?> {
+        val keysVersionResult = testHelper.doSync<KeysBackupLastVersionResult> {
             testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it)
-        }
+        }.toKeysVersionResult()
 
         // - It must be the same
         assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version)
@@ -463,9 +464,9 @@ class KeysBackupTest : InstrumentedTest {
         assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled)
 
         // - Retrieve the last version from the server
-        val keysVersionResult = testHelper.doSync<KeysVersionResult?> {
+        val keysVersionResult = testHelper.doSync<KeysBackupLastVersionResult> {
             testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it)
-        }
+        }.toKeysVersionResult()
 
         // - It must be the same
         assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version)
@@ -565,9 +566,9 @@ class KeysBackupTest : InstrumentedTest {
         assertTrue(testData.aliceSession2.cryptoService().keysBackupService().isEnabled)
 
         // - Retrieve the last version from the server
-        val keysVersionResult = testHelper.doSync<KeysVersionResult?> {
+        val keysVersionResult = testHelper.doSync<KeysBackupLastVersionResult> {
             testData.aliceSession2.cryptoService().keysBackupService().getCurrentVersion(it)
-        }
+        }.toKeysVersionResult()
 
         // - It must be the same
         assertEquals(testData.prepareKeysBackupDataResult.version, keysVersionResult!!.version)
@@ -835,9 +836,9 @@ class KeysBackupTest : InstrumentedTest {
         keysBackupTestHelper.prepareAndCreateKeysBackupData(keysBackup)
 
         // Get key backup version from the homeserver
-        val keysVersionResult = testHelper.doSync<KeysVersionResult?> {
+        val keysVersionResult = testHelper.doSync<KeysBackupLastVersionResult> {
             keysBackup.getCurrentVersion(it)
-        }
+        }.toKeysVersionResult()
 
         // - Check the returned KeyBackupVersion is trusted
         val keysBackupVersionTrust = testHelper.doSync<KeysBackupVersionTrust> {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/failure/Extensions.kt

@@ -29,6 +29,11 @@ fun Throwable.is401() =
                 httpCode == HttpsURLConnection.HTTP_UNAUTHORIZED && /* 401 */
                 error.code == MatrixError.M_UNAUTHORIZED
 
+fun Throwable.is404() =
+        this is Failure.ServerError &&
+                httpCode == HttpsURLConnection.HTTP_NOT_FOUND && /* 404 */
+                error.code == MatrixError.M_NOT_FOUND
+
 fun Throwable.isTokenError() =
         this is Failure.ServerError &&
                 (error.code == MatrixError.M_UNKNOWN_TOKEN ||

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/keysbackup/KeysBackupService.kt

@@ -19,6 +19,7 @@ package org.matrix.android.sdk.api.session.crypto.keysbackup
 import org.matrix.android.sdk.api.MatrixCallback
 import org.matrix.android.sdk.api.listeners.ProgressListener
 import org.matrix.android.sdk.api.listeners.StepProgressListener
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupVersionTrust
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion
@@ -31,9 +32,9 @@ interface KeysBackupService {
      * Retrieve the current version of the backup from the homeserver
      *
      * It can be different than keysBackupVersion.
-     * @param callback onSuccess(null) will be called if there is no backup on the server
+     * @param callback Asynchronous callback
      */
-    fun getCurrentVersion(callback: MatrixCallback<KeysVersionResult?>)
+    fun getCurrentVersion(callback: MatrixCallback<KeysBackupLastVersionResult>)
 
     /**
      * Create a new keys backup version and enable it, using the information return from [prepareKeysBackupVersion].

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/DefaultKeysBackupService.kt

@@ -41,6 +41,7 @@ import org.matrix.android.sdk.internal.crypto.MegolmSessionData
 import org.matrix.android.sdk.internal.crypto.ObjectSigner
 import org.matrix.android.sdk.internal.crypto.actions.MegolmSessionDataImporter
 import org.matrix.android.sdk.internal.crypto.crosssigning.fromBase64
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupVersionTrust
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupVersionTrustSignature
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupAuthData
@@ -54,6 +55,7 @@ import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.RoomKeysBackupData
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.UpdateKeysBackupVersionBody
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.CreateKeysBackupVersionTask
 import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteBackupTask
 import org.matrix.android.sdk.internal.crypto.keysbackup.tasks.DeleteRoomSessionDataTask
@@ -586,7 +588,12 @@ internal class DefaultKeysBackupService @Inject constructor(
 
         cryptoCoroutineScope.launch(coroutineDispatchers.main) {
             try {
-                val keysBackupVersion = getKeysBackupLastVersionTask.execute(Unit)
+                when (val keysBackupLastVersionResult = getKeysBackupLastVersionTask.execute(Unit)) {
+                    KeysBackupLastVersionResult.NoKeysBackup  -> {
+                        Timber.d("No keys backup found")
+                    }
+                    is KeysBackupLastVersionResult.KeysBackup -> {
+                        val keysBackupVersion = keysBackupLastVersionResult.keysVersionResult
                         val recoveryKey = computeRecoveryKey(secret.fromBase64())
                         if (isValidRecoveryKeyForKeysBackupVersion(recoveryKey, keysBackupVersion)) {
                             awaitCallback<Unit> {
@@ -602,6 +609,8 @@ internal class DefaultKeysBackupService @Inject constructor(
                         } else {
                             Timber.e("onSecretKeyGossip: Recovery key is not valid ${keysBackupVersion.version}")
                         }
+                    }
+                }
             } catch (failure: Throwable) {
                 Timber.e("onSecretKeyGossip: failed to trust key backup version ${keysBackupVersion?.version}")
             }
@@ -875,36 +884,20 @@ internal class DefaultKeysBackupService @Inject constructor(
                 .executeBy(taskExecutor)
     }
 
-    override fun getCurrentVersion(callback: MatrixCallback<KeysVersionResult?>) {
+    override fun getCurrentVersion(callback: MatrixCallback<KeysBackupLastVersionResult>) {
         getKeysBackupLastVersionTask
                 .configureWith {
-                    this.callback = object : MatrixCallback<KeysVersionResult> {
+                    this.callback = callback
-                        override fun onSuccess(data: KeysVersionResult) {
-                            callback.onSuccess(data)
-                        }
-
-                        override fun onFailure(failure: Throwable) {
-                            if (failure is Failure.ServerError &&
-                                    failure.error.code == MatrixError.M_NOT_FOUND) {
-                                // Workaround because the homeserver currently returns M_NOT_FOUND when there is no key backup
-                                callback.onSuccess(null)
-                            } else {
-                                // Transmit the error
-                                callback.onFailure(failure)
-                            }
-                        }
-                    }
                 }
                 .executeBy(taskExecutor)
     }
 
     override fun forceUsingLastVersion(callback: MatrixCallback<Boolean>) {
-        getCurrentVersion(object : MatrixCallback<KeysVersionResult?> {
+        getCurrentVersion(object : MatrixCallback<KeysBackupLastVersionResult> {
-            override fun onSuccess(data: KeysVersionResult?) {
+            override fun onSuccess(data: KeysBackupLastVersionResult) {
                 val localBackupVersion = keysBackupVersion?.version
-                val serverBackupVersion = data?.version
+                when (data) {
-
+                    KeysBackupLastVersionResult.NoKeysBackup  -> {
-                if (serverBackupVersion == null) {
                         if (localBackupVersion == null) {
                             // No backup on the server, and backup is not active
                             callback.onSuccess(true)
@@ -915,15 +908,16 @@ internal class DefaultKeysBackupService @Inject constructor(
                             keysBackupVersion = null
                             keysBackupStateManager.state = KeysBackupState.Disabled
                         }
-                } else {
+                    }
+                    is KeysBackupLastVersionResult.KeysBackup -> {
                         if (localBackupVersion == null) {
                             // backup on the server, and backup is not active
                             callback.onSuccess(false)
                             // Do a check
-                        checkAndStartWithKeysBackupVersion(data)
+                            checkAndStartWithKeysBackupVersion(data.keysVersionResult)
                         } else {
                             // Backup on the server, and we are currently backing up, compare version
-                        if (localBackupVersion == serverBackupVersion) {
+                            if (localBackupVersion == data.keysVersionResult.version) {
                                 // We are already using the last version of the backup
                                 callback.onSuccess(true)
                             } else {
@@ -936,6 +930,7 @@ internal class DefaultKeysBackupService @Inject constructor(
                         }
                     }
                 }
+            }
 
             override fun onFailure(failure: Throwable) {
                 callback.onFailure(failure)
@@ -954,9 +949,9 @@ internal class DefaultKeysBackupService @Inject constructor(
         keysBackupVersion = null
         keysBackupStateManager.state = KeysBackupState.CheckingBackUpOnHomeserver
 
-        getCurrentVersion(object : MatrixCallback<KeysVersionResult?> {
+        getCurrentVersion(object : MatrixCallback<KeysBackupLastVersionResult> {
-            override fun onSuccess(data: KeysVersionResult?) {
+            override fun onSuccess(data: KeysBackupLastVersionResult) {
-                checkAndStartWithKeysBackupVersion(data)
+                checkAndStartWithKeysBackupVersion(data.toKeysVersionResult())
             }
 
             override fun onFailure(failure: Throwable) {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/model/KeysBackupLastVersionResult.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 The Matrix.org Foundation C.I.C.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.internal.crypto.keysbackup.model
+
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+
+sealed interface KeysBackupLastVersionResult {
+    // No Keys backup found (404 error)
+    object NoKeysBackup : KeysBackupLastVersionResult
+    data class KeysBackup(val keysVersionResult: KeysVersionResult) : KeysBackupLastVersionResult
+}
+
+fun KeysBackupLastVersionResult.toKeysVersionResult(): KeysVersionResult? = when (this) {
+    is KeysBackupLastVersionResult.KeysBackup -> keysVersionResult
+    KeysBackupLastVersionResult.NoKeysBackup  -> null
+}

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/keysbackup/tasks/GetKeysBackupLastVersionTask.kt

@@ -16,23 +16,34 @@
 
 package org.matrix.android.sdk.internal.crypto.keysbackup.tasks
 
+import org.matrix.android.sdk.api.failure.is404
 import org.matrix.android.sdk.internal.crypto.keysbackup.api.RoomKeysApi
-import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.network.GlobalErrorReceiver
 import org.matrix.android.sdk.internal.network.executeRequest
 import org.matrix.android.sdk.internal.task.Task
 import javax.inject.Inject
 
-internal interface GetKeysBackupLastVersionTask : Task<Unit, KeysVersionResult>
+internal interface GetKeysBackupLastVersionTask : Task<Unit, KeysBackupLastVersionResult>
 
 internal class DefaultGetKeysBackupLastVersionTask @Inject constructor(
         private val roomKeysApi: RoomKeysApi,
         private val globalErrorReceiver: GlobalErrorReceiver
 ) : GetKeysBackupLastVersionTask {
 
-    override suspend fun execute(params: Unit): KeysVersionResult {
+    override suspend fun execute(params: Unit): KeysBackupLastVersionResult {
-        return executeRequest(globalErrorReceiver) {
+        return try {
+            val keysVersionResult = executeRequest(globalErrorReceiver) {
                 roomKeysApi.getKeysBackupLastVersion()
             }
+            KeysBackupLastVersionResult.KeysBackup(keysVersionResult)
+        } catch (throwable: Throwable) {
+            if (throwable.is404()) {
+                KeysBackupLastVersionResult.NoKeysBackup
+            } else {
+                // Propagate other errors
+                throw throwable
+            }
+        }
     }
 }

vector/src/main/java/im/vector/app/features/crypto/keysbackup/restore/KeysBackupRestoreSharedViewModel.kt

@@ -32,7 +32,9 @@ import org.matrix.android.sdk.api.session.crypto.crosssigning.KEYBACKUP_SECRET_S
 import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysBackupService
 import org.matrix.android.sdk.api.session.securestorage.KeyInfoResult
 import org.matrix.android.sdk.internal.crypto.crosssigning.fromBase64
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.util.computeRecoveryKey
 import org.matrix.android.sdk.internal.crypto.model.ImportRoomKeysResult
 import org.matrix.android.sdk.internal.util.awaitCallback
@@ -117,9 +119,9 @@ class KeysBackupRestoreSharedViewModel @Inject constructor(
 
         viewModelScope.launch(Dispatchers.IO) {
             try {
-                val version = awaitCallback<KeysVersionResult?> {
+                val version = awaitCallback<KeysBackupLastVersionResult> {
                     keysBackup.getCurrentVersion(it)
-                }
+                }.toKeysVersionResult()
                 if (version?.version == null) {
                     loadingEvent.postValue(null)
                     _keyVersionResultError.postValue(LiveEvent(stringProvider.getString(R.string.keys_backup_get_version_error, "")))

vector/src/main/java/im/vector/app/features/crypto/keysbackup/setup/KeysBackupSetupSharedViewModel.kt

@@ -27,9 +27,10 @@ import org.matrix.android.sdk.api.MatrixCallback
 import org.matrix.android.sdk.api.listeners.ProgressListener
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.crypto.keysbackup.KeysBackupService
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion
-import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -150,9 +151,9 @@ class KeysBackupSetupSharedViewModel @Inject constructor() : ViewModel() {
 
         creatingBackupError.value = null
 
-        keysBackup.getCurrentVersion(object : MatrixCallback<KeysVersionResult?> {
+        keysBackup.getCurrentVersion(object : MatrixCallback<KeysBackupLastVersionResult> {
-            override fun onSuccess(data: KeysVersionResult?) {
+            override fun onSuccess(data: KeysBackupLastVersionResult) {
-                if (data?.version.isNullOrBlank() || forceOverride) {
+                if (data.toKeysVersionResult()?.version.isNullOrBlank() || forceOverride) {
                     processOnCreate()
                 } else {
                     loadingStatus.value = null

vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapCrossSigningTask.kt

@@ -33,9 +33,10 @@ import org.matrix.android.sdk.api.session.securestorage.SharedSecretStorageServi
 import org.matrix.android.sdk.api.session.securestorage.SsssKeyCreationInfo
 import org.matrix.android.sdk.api.session.securestorage.SsssKeySpec
 import org.matrix.android.sdk.internal.crypto.crosssigning.toBase64NoPadding
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.MegolmBackupCreationInfo
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersion
-import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.util.extractCurveKeyFromRecoveryKey
 import org.matrix.android.sdk.internal.util.awaitCallback
 import timber.log.Timber
@@ -221,10 +222,9 @@ class BootstrapCrossSigningTask @Inject constructor(
             Timber.d("## BootstrapCrossSigningTask: Creating 4S - Checking megolm backup")
 
             // First ensure that in sync
-            var serverVersion = awaitCallback<KeysVersionResult?> {
+            var serverVersion = awaitCallback<KeysBackupLastVersionResult> {
                 session.cryptoService().keysBackupService().getCurrentVersion(it)
-            }
+            }.toKeysVersionResult()
-
             val knownMegolmSecret = session.cryptoService().keysBackupService().getKeyBackupRecoveryKeyInfo()
             val isMegolmBackupSecretKnown = knownMegolmSecret != null && knownMegolmSecret.version == serverVersion?.version
             val shouldCreateKeyBackup = serverVersion == null ||
@@ -236,9 +236,9 @@ class BootstrapCrossSigningTask @Inject constructor(
                     awaitCallback<Unit> {
                         session.cryptoService().keysBackupService().deleteBackup(serverVersion!!.version, it)
                     }
-                    serverVersion = awaitCallback {
+                    serverVersion = awaitCallback<KeysBackupLastVersionResult> {
                         session.cryptoService().keysBackupService().getCurrentVersion(it)
-                    }
+                    }.toKeysVersionResult()
                 }
 
                 Timber.d("## BootstrapCrossSigningTask: Creating 4S - Create megolm backup")

vector/src/main/java/im/vector/app/features/crypto/recover/BootstrapSharedViewModel.kt

@@ -45,7 +45,9 @@ import org.matrix.android.sdk.api.failure.Failure
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.securestorage.RawBytesKeySpec
 import org.matrix.android.sdk.internal.crypto.crosssigning.fromBase64
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.util.extractCurveKeyFromRecoveryKey
 import org.matrix.android.sdk.internal.crypto.model.rest.DefaultBaseAuth
 import org.matrix.android.sdk.internal.util.awaitCallback
@@ -103,9 +105,9 @@ class BootstrapSharedViewModel @AssistedInject constructor(
 
                 // We need to check if there is an existing backup
                 viewModelScope.launch(Dispatchers.IO) {
-                    val version = awaitCallback<KeysVersionResult?> {
+                    val version = awaitCallback<KeysBackupLastVersionResult> {
                         session.cryptoService().keysBackupService().getCurrentVersion(it)
-                    }
+                    }.toKeysVersionResult()
                     if (version == null) {
                         // we just resume plain bootstrap
                         doesKeyBackupExist = false

vector/src/main/java/im/vector/app/features/crypto/verification/VerificationBottomSheetViewModel.kt

@@ -52,7 +52,8 @@ import org.matrix.android.sdk.api.util.MatrixItem
 import org.matrix.android.sdk.api.util.toMatrixItem
 import org.matrix.android.sdk.internal.crypto.crosssigning.fromBase64
 import org.matrix.android.sdk.internal.crypto.crosssigning.isVerified
-import org.matrix.android.sdk.internal.crypto.keysbackup.model.rest.KeysVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.KeysBackupLastVersionResult
+import org.matrix.android.sdk.internal.crypto.keysbackup.model.toKeysVersionResult
 import org.matrix.android.sdk.internal.crypto.keysbackup.util.computeRecoveryKey
 import org.matrix.android.sdk.internal.crypto.model.ImportRoomKeysResult
 import org.matrix.android.sdk.internal.util.awaitCallback
@@ -426,9 +427,9 @@ class VerificationBottomSheetViewModel @AssistedInject constructor(
                     Timber.v("## Keybackup secret not restored from SSSS")
                 }
 
-                val version = awaitCallback<KeysVersionResult?> {
+                val version = awaitCallback<KeysBackupLastVersionResult> {
                     session.cryptoService().keysBackupService().getCurrentVersion(it)
-                } ?: return@launch
+                }.toKeysVersionResult() ?: return@launch
 
                 awaitCallback<ImportRoomKeysResult> {
                     session.cryptoService().keysBackupService().restoreKeysWithRecoveryKey(