Merge pull request #1893 from walt-id/feature/wal-1077-transaction-data-support

[WAL-1077] feat(mobile): add transaction data support

Author: szijpeter

.github/scripts/mobile-ci/run-android-compose-demo-tests.sh

@@ -6,4 +6,5 @@ identity_dir="$(cd "$script_dir/../../.." && pwd -P)"
 
 "$identity_dir/gradlew" -p "$identity_dir" \
   :waltid-applications:waltid-wallet-demo-compose:androidApp:connectedDebugAndroidTest \
+  -PtransactionDataProfiles.url=https://wallet.demo.walt.id/wallet-api/transaction-data-profiles \
   --info

waltid-applications/mobile-e2e-fixtures/ios/TestHelpers/DemoBackend.swift

@@ -21,6 +21,9 @@ public struct DemoVerifierSession {
 public final class DemoBackend {
     public static let shared = DemoBackend()
     private static let eudiPidSdJwtVct = "https://issuer2.demo.walt.id/openid4vci/urn:eudi:pid:1"
+    public static let transactionDataProfilesURL = URL(string: "https://wallet.demo.walt.id/wallet-api/transaction-data-profiles")!
+    private static let paymentAuthorizationType = "org.waltid.transaction-data.payment-authorization"
+    private static let requiredPaymentAuthorizationFields: Set<String> = ["amount", "currency", "payee"]
 
     public static let scenarios: [DemoCredentialScenario] = [
         DemoCredentialScenario(
@@ -64,6 +67,8 @@ public final class DemoBackend {
 
     public static let presentationScenarios = scenarios
 
+    public static let transactionDataPresentationScenario = scenarios.first { $0.id == "eudi-pid-sdjwt" }!
+
     public static let persistenceScenario = scenarios.first { $0.id == "eudi-pid-mdoc" }!
 
     private static let issuerBaseURL = URL(string: "https://issuer2.demo.walt.id")!
@@ -102,17 +107,66 @@ public final class DemoBackend {
     }
 
     public func createVerifierSession(scenario: DemoCredentialScenario) async throws -> DemoVerifierSession {
+        try await createVerifierSession(
+            scenario: scenario,
+            transactionData: []
+        )
+    }
+
+    public func createTransactionDataVerifierSession(
+        scenario: DemoCredentialScenario = DemoBackend.transactionDataPresentationScenario
+    ) async throws -> DemoVerifierSession {
+        let fields = try await transactionDataProfileFields(type: Self.paymentAuthorizationType)
+        let missingFields = Self.requiredPaymentAuthorizationFields.subtracting(fields)
+        guard missingFields.isEmpty else {
+            throw NSError(
+                domain: "WalletE2E",
+                code: 305,
+                userInfo: [NSLocalizedDescriptionKey: "Public demo transaction data profile '\(Self.paymentAuthorizationType)' is missing required fields: \(missingFields.sorted().joined(separator: ", "))"]
+            )
+        }
+        return try await createVerifierSession(
+            scenario: scenario,
+            transactionData: [Self.paymentAuthorizationTransactionData(credentialID: "pid", fields: fields)]
+        )
+    }
+
+    public func transactionDataProfileFields(type: String) async throws -> Set<String> {
+        let response = try await client.textRequest(
+            url: Self.transactionDataProfilesURL,
+            retryTransientFailures: true
+        )
+        let json = try JSONSerialization.jsonObject(with: Data(response.body.utf8), options: [])
+        guard let profiles = json as? [[String: Any]],
+              let profile = profiles.first(where: { $0["type"] as? String == type }),
+              let fields = profile["fields"] as? [String] else {
+            throw NSError(
+                domain: "WalletE2E",
+                code: 306,
+                userInfo: [NSLocalizedDescriptionKey: "Missing public demo transaction data profile: \(type)"]
+            )
+        }
+        return Set(fields)
+    }
+
+    private func createVerifierSession(
+        scenario: DemoCredentialScenario,
+        transactionData: [[String: Any]]
+    ) async throws -> DemoVerifierSession {
         let endpoint = Self.verifierBaseURL
             .appendingPathComponent("verification-session")
             .appendingPathComponent("create")
-        let payload: [String: Any] = [
+        var payload: [String: Any] = [
             "flow_type": "cross_device",
             "core_flow": [
                 "dcql_query": [
                     "credentials": [scenario.verifierCredentialQuery],
                 ],
             ],
         ]
+        if !transactionData.isEmpty {
+            payload["openid"] = ["transactionData": transactionData]
+        }
         let response = try await client.jsonRequest(
             url: endpoint,
             method: "POST",
@@ -204,4 +258,25 @@ public final class DemoBackend {
             "claims": claims.map { ["path": [namespace, $0]] },
         ]
     }
+
+    private static func paymentAuthorizationTransactionData(credentialID: String, fields: Set<String>) -> [String: Any] {
+        var payload: [String: Any] = [
+            "type": paymentAuthorizationType,
+            "credential_ids": [credentialID],
+            "require_cryptographic_holder_binding": true,
+            "transaction_data_hashes_alg": ["sha-256"],
+        ]
+        payload.putProfileField(fields: fields, key: "amount", value: "42.00")
+        payload.putProfileField(fields: fields, key: "currency", value: "EUR")
+        payload.putProfileField(fields: fields, key: "payee", value: "ACME Corp")
+        return payload
+    }
+}
+
+private extension Dictionary where Key == String, Value == Any {
+    mutating func putProfileField(fields: Set<String>, key: String, value: String) {
+        if fields.contains(key) {
+            self[key] = value
+        }
+    }
 }

waltid-applications/waltid-wallet-demo-compose/README.md

@@ -32,6 +32,16 @@ Android and iOS demo targets use the default managed encrypted local persistence
 
 The UI stays focused on the production default. Non-default persistence options, including provided database keys and custom stores, are documented and tested at the SDK layer.
 
+## Public demo backend defaults
+
+Clean demo installs use the public walt.id demo profile endpoint for OpenID4VP transaction-data support:
+
+```text
+https://wallet.demo.walt.id/wallet-api/transaction-data-profiles
+```
+
+Android builds can override it with `-PtransactionDataProfiles.url=...`. Compose iOS can override it with the `TRANSACTION_DATA_PROFILES_URL` launch environment variable or `UserDefaults` key. Wallet attestation values remain explicit overrides through `attestation.*` Gradle properties on Android and `ATTESTATION_*` environment/UserDefaults values on iOS; no bearer token is defaulted.
+
 ## Target status
 
 - Android and iOS are the supported mobile demo targets for wallet SDK issuance, presentation, platform-backed keys, and persistence.

waltid-applications/waltid-wallet-demo-compose/androidApp/build.gradle.kts

@@ -6,6 +6,7 @@ plugins {
 }
 
 val javaVersion = identityLibs.versions.java.library.get().toInt()
+val publicDemoTransactionDataProfilesUrl = "https://wallet.demo.walt.id/wallet-api/transaction-data-profiles"
 
 android {
     namespace = "id.walt.walletdemo.compose.android"
@@ -23,6 +24,7 @@ android {
         buildConfigField("String", "ATTESTATION_ATTESTER_PATH", "\"${findProperty("attestation.attesterPath") ?: ""}\"")
         buildConfigField("String", "ATTESTATION_BEARER_TOKEN", "\"${findProperty("attestation.bearerToken") ?: ""}\"")
         buildConfigField("String", "ATTESTATION_HOST_HEADER", "\"${findProperty("attestation.hostHeader") ?: ""}\"")
+        buildConfigField("String", "TRANSACTION_DATA_PROFILES_URL", "\"${findProperty("transactionDataProfiles.url") ?: publicDemoTransactionDataProfilesUrl}\"")
     }
 
     buildFeatures {

waltid-applications/waltid-wallet-demo-compose/androidApp/src/androidTest/java/id/walt/walletdemo/compose/android/PublicDemoBackendE2ETest.kt

@@ -8,7 +8,9 @@ import id.walt.mobile.test.backend.DemoTestBackend
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.CREDENTIAL_OPERATION_TIMEOUT
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.UI_ELEMENT_TIMEOUT
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.VERIFIER_POLLING_TIMEOUT
+import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.assertClaimValueVisibleAfterScrolling
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.assertResourceTextEquals
+import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.assertTextVisibleAfterScrolling
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.clickByTag
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.launchAndUnlock
 import id.walt.walletdemo.compose.android.WalletComposeE2EHelper.latestStatus
@@ -18,6 +20,7 @@ import kotlinx.coroutines.runBlocking
 import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.junit.runner.RunWith
+import java.io.File
 
 @RunWith(AndroidJUnit4::class)
 class PublicDemoBackendE2ETest {
@@ -94,4 +97,87 @@ class PublicDemoBackendE2ETest {
 
         DemoTestBackend.waitForVerifierSuccess(session.sessionId, timeoutMs = VERIFIER_POLLING_TIMEOUT)
     }
+
+    @Test
+    fun transactionDataPreviewAgainstPublicDemoIssuer2Verifier2() = runBlocking {
+        val scenario = DemoTestBackend.transactionDataPresentationScenario
+        val offer = DemoTestBackend.createOffer(scenario)
+
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+        val context = instrumentation.targetContext
+        val device = UiDevice.getInstance(instrumentation)
+
+        launchAndUnlock(context, device)
+
+        sendDeepLink(context, offer.offerUrl)
+        assertResourceTextEquals(
+            device = device,
+            tag = "wallet.offerInput",
+            expected = offer.offerUrl,
+            timeoutMs = UI_ELEMENT_TIMEOUT,
+            message = "Offer URL did not appear in UI after deep link",
+        )
+
+        clickByTag(device, "wallet.receiveButton")
+        val receiveSuccess = waitForStatus(
+            device = device,
+            timeoutMs = CREDENTIAL_OPERATION_TIMEOUT,
+            matcher = { it.startsWith("Received") },
+            failurePrefixes = listOf("Receive failed", "Bootstrap failed", "Present failed")
+        )
+        assertTrue("Receive did not complete successfully. Latest status: ${latestStatus(device)}", receiveSuccess)
+
+        val session = DemoTestBackend.createTransactionDataVerifierSession(scenario)
+        sendDeepLink(context, session.authorizationRequestUri)
+        assertResourceTextEquals(
+            device = device,
+            tag = "wallet.presentationInput",
+            expected = session.authorizationRequestUri,
+            timeoutMs = UI_ELEMENT_TIMEOUT,
+            message = "Presentation request URL did not appear in UI after deep link",
+        )
+
+        clickByTag(device, "wallet.presentButton")
+        val previewReady = waitForStatus(
+            device = device,
+            timeoutMs = CREDENTIAL_OPERATION_TIMEOUT,
+            matcher = { it == "Review presentation request" },
+            failurePrefixes = listOf("Preview failed", "Present failed", "Receive failed", "Bootstrap failed")
+        )
+        assertTrue("Transaction-data preview did not load. Latest status: ${latestStatus(device)}", previewReady)
+
+        val screenshot = File("/sdcard/Download/wal1077-compose-android-transaction-data.png")
+        if (device.takeScreenshot(screenshot)) {
+            println("WAL1077_SCREENSHOT=${screenshot.absolutePath}")
+        } else {
+            println("WAL1077_SCREENSHOT_CAPTURE_FAILED=${screenshot.absolutePath}")
+        }
+
+        assertTextVisibleAfterScrolling(
+            device,
+            listOf("PAYMENT AUTHORIZATION", "Payment Authorization"),
+            "Payment profile title missing",
+        )
+        assertClaimValueVisibleAfterScrolling(
+            device = device,
+            path = "transactionData[0].details.amount",
+            label = "Amount",
+            expectedValues = listOf("42.00"),
+            message = "Payment amount missing",
+        )
+        assertClaimValueVisibleAfterScrolling(
+            device = device,
+            path = "transactionData[0].details.currency",
+            label = "Currency",
+            expectedValues = listOf("EUR"),
+            message = "Payment currency missing",
+        )
+        assertClaimValueVisibleAfterScrolling(
+            device = device,
+            path = "transactionData[0].details.payee",
+            label = "Payee",
+            expectedValues = listOf("ACME Corp"),
+            message = "Payment payee missing",
+        )
+    }
 }

waltid-applications/waltid-wallet-demo-compose/androidApp/src/androidTest/java/id/walt/walletdemo/compose/android/WalletComposeE2EHelper.kt

@@ -115,6 +115,47 @@ internal object WalletComposeE2EHelper {
         device.waitForIdle()
     }
 
+    fun assertTextVisibleAfterScrolling(
+        device: UiDevice,
+        texts: List<String>,
+        message: String,
+    ) {
+        if (findTextAfterScrolling(device, texts) != null) return
+        fail("$message. Expected one of $texts.\n${visibleUiSnapshot(device)}")
+    }
+
+    fun assertClaimValueVisibleAfterScrolling(
+        device: UiDevice,
+        path: String,
+        label: String,
+        expectedValues: List<String>,
+        message: String,
+    ) {
+        val tag = claimTag(path)
+        val node = waitForResource(device, tag, CLICK_VISIBLE_TIMEOUT)
+            ?: findVisibleResource(device, tag)
+            ?: findResourceAfterScrolling(device, tag)
+        if (node == null) {
+            fail("$message. Claim row $tag not found.\n${visibleUiSnapshot(device)}")
+            return
+        }
+        val visibleTexts = node.flatten()
+            .mapNotNull { it.text?.trim()?.takeIf(String::isNotEmpty) }
+        val missingValues = expectedValues.filter { expected -> expected !in visibleTexts }
+        if (label !in visibleTexts || missingValues.isNotEmpty()) {
+            fail(
+                """
+                    $message.
+                    claim=$tag
+                    expectedLabel=$label
+                    expectedValues=$expectedValues
+                    visibleTexts=$visibleTexts
+                    ${visibleUiSnapshot(device)}
+                """.trimIndent()
+            )
+        }
+    }
+
     fun waitForResource(device: UiDevice, tag: String, timeoutMs: Long): UiObject2? {
         val deadline = System.currentTimeMillis() + timeoutMs
         while (System.currentTimeMillis() < deadline) {
@@ -126,6 +167,26 @@ internal object WalletComposeE2EHelper {
         return null
     }
 
+    private fun findTextAfterScrolling(device: UiDevice, texts: List<String>): UiObject2? {
+        findVisibleText(device, texts)?.let { return it }
+        repeat(6) {
+            device.scrollDown()
+            findVisibleText(device, texts)?.let { return it }
+        }
+        repeat(12) {
+            device.scrollUp()
+            findVisibleText(device, texts)?.let { return it }
+        }
+        return null
+    }
+
+    private fun findVisibleText(device: UiDevice, texts: List<String>): UiObject2? =
+        device.findObjects(By.pkg("id.walt.walletdemo.compose"))
+            .flatMap { it.flatten() }
+            .firstOrNull { node ->
+                runCatching { node.text?.trim() in texts }.getOrDefault(false)
+            }
+
     private fun findVisibleResource(device: UiDevice, tag: String): UiObject2? =
         device.findObjects(By.pkg("id.walt.walletdemo.compose"))
             .flatMap { it.flatten() }
@@ -135,20 +196,43 @@ internal object WalletComposeE2EHelper {
 
     private fun findResourceAfterScrolling(device: UiDevice, tag: String): UiObject2? {
         repeat(6) {
-            device.swipe(
-                device.displayWidth / 2,
-                (device.displayHeight * 0.72).toInt(),
-                device.displayWidth / 2,
-                (device.displayHeight * 0.36).toInt(),
-                24,
-            )
-            device.waitForIdle()
+            device.scrollDown()
+            waitForResource(device, tag, 1_000L)?.let { return it }
+            findVisibleResource(device, tag)?.let { return it }
+        }
+        repeat(12) {
+            device.scrollUp()
             waitForResource(device, tag, 1_000L)?.let { return it }
             findVisibleResource(device, tag)?.let { return it }
         }
         return null
     }
 
+    private fun claimTag(path: String): String =
+        "wallet.claim.${path.map { if (it.isLetterOrDigit()) it else '_' }.joinToString("")}"
+
+    private fun UiDevice.scrollDown() {
+        swipe(
+            displayWidth / 2,
+            (displayHeight * 0.72).toInt(),
+            displayWidth / 2,
+            (displayHeight * 0.36).toInt(),
+            24,
+        )
+        waitForIdle()
+    }
+
+    private fun UiDevice.scrollUp() {
+        swipe(
+            displayWidth / 2,
+            (displayHeight * 0.36).toInt(),
+            displayWidth / 2,
+            (displayHeight * 0.72).toInt(),
+            24,
+        )
+        waitForIdle()
+    }
+
     fun latestStatus(device: UiDevice): String {
         val tagged = device.findObject(By.res("wallet.status"))
         if (tagged?.text != null) return tagged.text

waltid-applications/waltid-wallet-demo-compose/androidApp/src/main/java/id/walt/walletdemo/compose/android/MainActivity.kt

@@ -25,6 +25,7 @@ class MainActivity : ComponentActivity() {
                     attestationAttesterPath = BuildConfig.ATTESTATION_ATTESTER_PATH,
                     attestationBearerToken = BuildConfig.ATTESTATION_BEARER_TOKEN,
                     attestationHostHeader = BuildConfig.ATTESTATION_HOST_HEADER,
+                    transactionDataProfilesUrl = BuildConfig.TRANSACTION_DATA_PROFILES_URL,
                 )
             )
         )