fix(WAL-995): clean up interrupted issuance sessions

Author: szijpeter

waltid-libraries/protocols/waltid-openid4vc-wallet-mobile/src/commonMain/kotlin/id/walt/wallet2/mobile/MobileWallet.kt

@@ -585,10 +585,13 @@ public class MobileWallet internal constructor(
     /**
      * Deletes local wallet material owned by this mobile wallet instance.
      *
-     * The active key, credential, and DID stores receive store-level remove calls. The wallet then closes
-     * and deletes the encrypted local database and deletes the configured database key.
+     * Active issuance continuations are invalidated before the key, credential, and DID stores receive
+     * store-level remove calls. The wallet then closes and deletes the encrypted local database and deletes
+     * the configured database key.
      */
     public suspend fun deleteWallet() {
+        issuanceSessions.clearSessions()
+        legacyIssuanceMutex.withLock { legacyIssuanceSessions.clear() }
         keyStore.listKeys().toList().forEach { key ->
             keyStore.removeKey(key.keyId)
         }

waltid-libraries/protocols/waltid-openid4vc-wallet-mobile/src/commonTest/kotlin/id/walt/wallet2/mobile/MobileWalletTest.kt

@@ -12,6 +12,9 @@ import id.walt.wallet2.data.WalletDidStore
 import id.walt.wallet2.data.WalletKeyInfo
 import id.walt.wallet2.data.WalletKeyStore
 import id.walt.wallet2.data.WalletSessionEvent
+import id.walt.wallet2.handlers.WalletIssuanceSessionRecord
+import id.walt.wallet2.handlers.WalletIssuanceSessionRecordKind
+import id.walt.wallet2.handlers.WalletIssuanceSessionStore
 import id.walt.wallet2.persistence.encryption.DatabaseEncryptionKey
 import id.walt.wallet2.persistence.encryption.DatabaseEncryptionKeyProvider
 import id.waltid.openid4vp.wallet.WalletPresentFunctionality2.WalletPresentResult
@@ -147,11 +150,28 @@ class MobileWalletTest {
         val keyStore = PreloadedKeyStore(WalletKeyInfo(keyId = "custom-key", keyType = "secp256r1"))
         val didStore = PreloadedDidStore(WalletDidEntry(did = "did:key:custom", document = JsonObject(emptyMap())))
         val credentialStore = RecordingCredentialStore()
+        val issuanceSessionStore = RecordingIssuanceSessionStore(
+            WalletIssuanceSessionRecord(
+                id = "active:session-1",
+                sessionId = "session-1",
+                kind = WalletIssuanceSessionRecordKind.ACTIVE_SESSION,
+                payload = "<encrypted>",
+                updatedAtEpochMilliseconds = 1L,
+            ),
+            WalletIssuanceSessionRecord(
+                id = "deferred:credential-1",
+                sessionId = "session-1",
+                kind = WalletIssuanceSessionRecordKind.DEFERRED_CREDENTIAL,
+                payload = "<encrypted>",
+                updatedAtEpochMilliseconds = 2L,
+            ),
+        )
         val wallet = MobileWallet(
             walletId = "custom-wallet",
             keyStore = keyStore,
             didStore = didStore,
             credentialStore = credentialStore,
+            issuanceSessionStore = issuanceSessionStore,
             keyGenerator = { error("deleteWallet should not generate a key") },
         )
 
@@ -160,6 +180,7 @@ class MobileWalletTest {
         assertEquals(listOf("custom-key"), keyStore.removedKeyIds)
         assertEquals(listOf("did:key:custom"), didStore.removedDids)
         assertEquals(emptyList(), credentialStore.removedCredentialIds)
+        assertTrue(issuanceSessionStore.records.isEmpty())
     }
 
     @Test
@@ -452,4 +473,17 @@ class MobileWalletTest {
             return true
         }
     }
+
+    private class RecordingIssuanceSessionStore(
+        vararg records: WalletIssuanceSessionRecord,
+    ) : WalletIssuanceSessionStore {
+        val records = records.associateByTo(linkedMapOf()) { it.id }
+
+        override suspend fun get(id: String): WalletIssuanceSessionRecord? = records[id]
+        override suspend fun list(): List<WalletIssuanceSessionRecord> = records.values.toList()
+        override suspend fun put(record: WalletIssuanceSessionRecord) {
+            records[record.id] = record
+        }
+        override suspend fun remove(id: String): Boolean = records.remove(id) != null
+    }
 }

waltid-libraries/protocols/waltid-openid4vc-wallet/src/commonMain/kotlin/id/walt/wallet2/handlers/WalletIssuanceSessionService.kt

@@ -418,6 +418,19 @@ class WalletIssuanceSessionService(
         return if (removed) WalletIssuanceOutcome.Cancelled(sessionId) else invalidSession(sessionId)
     }
 
+    /** Invalidates and removes every active and deferred issuance continuation. */
+    suspend fun clearSessions() {
+        withContext(NonCancellable) {
+            mutex.withLock {
+                sessions.clear()
+                deferred.clear()
+            }
+            sessionStore?.let { store ->
+                store.list().forEach { store.remove(it.id) }
+            }
+        }
+    }
+
     /** Polls one deferred result while preserving its access material inside the engine. */
     suspend fun resumeDeferred(deferredCredentialId: String): WalletIssuanceOutcome {
         val record = try {
@@ -1136,22 +1149,28 @@ class WalletIssuanceSessionService(
         try {
             persistActive(active)
         } catch (error: CancellationException) {
+            invalidateActiveSessionBestEffort(sessionId)
             throw error
         } catch (error: Exception) {
-            mutex.withLock { active.state = expected }
+            invalidateActiveSessionBestEffort(sessionId)
             throw IssuanceStageException(WalletIssuanceErrorCode.STORAGE, error)
         }
         return active
     }
 
     private suspend fun loadActive(sessionId: String): ActiveSession? {
         mutex.withLock { sessions[sessionId] }?.let { return it }
-        val record = sessionStore?.get(activeRecordId(sessionId)) ?: return null
+        val store = sessionStore ?: return null
+        val record = store.get(activeRecordId(sessionId)) ?: return null
         require(record.kind == WalletIssuanceSessionRecordKind.ACTIVE_SESSION && record.sessionId == sessionId) {
             "Stored issuance session binding is invalid"
         }
         val persisted = json.decodeFromString<PersistedActiveSession>(record.payload)
         require(persisted.public.id == sessionId) { "Stored issuance session identifier is invalid" }
+        if (persisted.state == SessionState.PROCESSING) {
+            invalidateActiveSessionBestEffort(sessionId)
+            return null
+        }
 
         val offer = json.decodeFromString<CredentialOffer>(persisted.offer)
         val issuerMetadata = json.decodeFromString<CredentialIssuerMetadata>(persisted.issuerMetadata)
@@ -1385,6 +1404,17 @@ class WalletIssuanceSessionService(
         removePersistedActive(sessionId)
     }
 
+    private suspend fun invalidateActiveSessionBestEffort(sessionId: String) {
+        withContext(NonCancellable) {
+            mutex.withLock { sessions.remove(sessionId) }
+            try {
+                removePersistedActive(sessionId)
+            } catch (_: Exception) {
+                // A retained PROCESSING marker is rejected when the session is next loaded.
+            }
+        }
+    }
+
     private suspend fun restoreSession(active: ActiveSession, state: SessionState) {
         var restored = false
         mutex.withLock {

waltid-libraries/protocols/waltid-openid4vc-wallet/src/jvmTest/kotlin/id/walt/wallet2/handlers/WalletIssuanceSessionServiceTest.kt

@@ -325,6 +325,124 @@ class WalletIssuanceSessionServiceTest {
         })
     }
 
+    @Test
+    fun cancellationWhilePersistingTransitionInvalidatesSession() = runTest {
+        val key = JWKKey.generate(KeyType.secp256r1)
+        val records = BlockingTransitionSessionStore()
+        val client = client { request ->
+            when (request.url.toString()) {
+                ISSUER_METADATA -> jsonResponse(issuerMetadata(proofRequired = false))
+                AS_METADATA -> jsonResponse(authorizationServerMetadata(authorizationCode = false))
+                else -> respondError(HttpStatusCode.NotFound)
+            }
+        }
+        val service = WalletIssuanceSessionService(
+            wallet = Wallet("transition-cancellation", staticKey = key),
+            sessionStore = records,
+            httpClient = client,
+        )
+        val session = service.start(preAuthorizedRequest())
+
+        val continuation = async { service.continuePreAuthorized(session.id) }
+        records.processingWriteStarted.await()
+        continuation.cancel()
+
+        assertFailsWith<CancellationException> { continuation.await() }
+        assertTrue(records.records.isEmpty())
+        assertEquals(
+            WalletIssuanceErrorCode.INVALID_SESSION,
+            assertIs<WalletIssuanceOutcome.Failed>(service.continuePreAuthorized(session.id)).error.code,
+        )
+    }
+
+    @Test
+    fun processingSessionIsDiscardedAfterServiceRecreation() = runTest {
+        val key = JWKKey.generate(KeyType.secp256r1)
+        val records = RecordingSessionStore()
+        val client = client { request ->
+            when (request.url.toString()) {
+                ISSUER_METADATA -> jsonResponse(issuerMetadata(proofRequired = false))
+                AS_METADATA -> jsonResponse(authorizationServerMetadata(authorizationCode = false))
+                else -> respondError(HttpStatusCode.NotFound)
+            }
+        }
+        val wallet = Wallet("interrupted-transition", staticKey = key)
+        val session = WalletIssuanceSessionService(wallet, sessionStore = records, httpClient = client)
+            .start(preAuthorizedRequest())
+        val active = records.records.values.single()
+        val processingPayload = active.payload.replace("\"state\":\"READY\"", "\"state\":\"PROCESSING\"")
+        assertTrue(processingPayload != active.payload)
+        records.records[active.id] = active.copy(payload = processingPayload)
+
+        val restored = WalletIssuanceSessionService(wallet, sessionStore = records, httpClient = client)
+        val outcome = restored.continuePreAuthorized(session.id)
+
+        assertEquals(
+            WalletIssuanceErrorCode.INVALID_SESSION,
+            assertIs<WalletIssuanceOutcome.Failed>(outcome).error.code,
+        )
+        assertTrue(records.records.isEmpty())
+    }
+
+    @Test
+    fun clearSessionsRemovesActiveAndDeferredContinuations() = runTest {
+        val key = JWKKey.generate(KeyType.secp256r1)
+        val records = RecordingSessionStore()
+        var authorizationServerMetadataCalls = 0
+        val client = client { request ->
+            when (request.url.toString()) {
+                ISSUER_METADATA -> jsonResponse(issuerMetadata(proofRequired = false))
+                AS_METADATA -> jsonResponse(
+                    authorizationServerMetadata(authorizationCode = authorizationServerMetadataCalls++ == 0)
+                )
+                TOKEN_ENDPOINT -> jsonResponse("""{"access_token":"access","token_type":"Bearer"}""")
+                CREDENTIAL_ENDPOINT -> jsonResponse(
+                    """{"transaction_id":"transaction-1","interval":5}""",
+                    HttpStatusCode.Accepted,
+                )
+                else -> respondError(HttpStatusCode.NotFound)
+            }
+        }
+        val service = WalletIssuanceSessionService(
+            wallet = Wallet("clear-sessions", staticKey = key),
+            sessionStore = records,
+            httpClient = client,
+        )
+        val authorization = service.start(authRequest())
+        val preAuthorized = service.start(preAuthorizedRequest())
+        val deferred = assertIs<WalletIssuanceOutcome.Deferred>(
+            service.continuePreAuthorized(preAuthorized.id)
+        )
+        assertEquals(
+            setOf(
+                WalletIssuanceSessionRecordKind.ACTIVE_SESSION,
+                WalletIssuanceSessionRecordKind.DEFERRED_CREDENTIAL,
+            ),
+            records.records.values.map { it.kind }.toSet(),
+        )
+
+        service.clearSessions()
+
+        assertTrue(records.records.isEmpty())
+        assertEquals(
+            WalletIssuanceErrorCode.INVALID_SESSION,
+            assertIs<WalletIssuanceOutcome.Failed>(
+                service.continueAuthorization(
+                    WalletIssuanceAuthorizationCallback(
+                        authorization.id,
+                        callback(authorization, "after-clear"),
+                    )
+                )
+            ).error.code,
+        )
+        assertEquals(
+            WalletIssuanceErrorCode.INVALID_SESSION,
+            assertIs<WalletIssuanceOutcome.Failed>(
+                service.resumeDeferred(deferred.credentials.single().id)
+            ).error.code,
+        )
+    }
+
     @Test
     fun deferredCredentialCanBeResumedAndStored() = runTest {
         val key = JWKKey.generate(KeyType.secp256r1)
@@ -1004,4 +1122,20 @@ class WalletIssuanceSessionServiceTest {
         }
         override suspend fun remove(id: String): Boolean = records.remove(id) != null
     }
+
+    private class BlockingTransitionSessionStore : WalletIssuanceSessionStore {
+        val records = linkedMapOf<String, WalletIssuanceSessionRecord>()
+        val processingWriteStarted = CompletableDeferred<Unit>()
+
+        override suspend fun get(id: String): WalletIssuanceSessionRecord? = records[id]
+        override suspend fun list(): List<WalletIssuanceSessionRecord> = records.values.toList()
+        override suspend fun put(record: WalletIssuanceSessionRecord) {
+            if ("\"state\":\"PROCESSING\"" in record.payload) {
+                processingWriteStarted.complete(Unit)
+                kotlinx.coroutines.awaitCancellation()
+            }
+            records[record.id] = record
+        }
+        override suspend fun remove(id: String): Boolean = records.remove(id) != null
+    }
 }