`av-app-android-wallet-ui`: The EU’s Age-Verification Wallet That Proves Less, Not More

A modular Android reference app for selective disclosure, hardware-backed key protection, and standards-based proof of age.

8 min read • View on GitHub • More from eu-digital-identity-wallet

A sealed credential envelope is handed toward a checkpoint gate, but the gate only reads a single 18+ stamp. A small armored vault sits behind the envelope, holding the rest of the identity document out of view. The scene explains the app’s core promise: reveal only the minimum proof needed, not the whole identity.
The wallet is built to answer one question and refuse the rest.
Key Takeaways

Proof of age is the product

The interesting thing about av-app-android-wallet-ui is not that it can verify age. It is that it tries to do so without turning identity into a data dump. The verifier gets an answer like “over 18,” not a dossier.

That distinction matters. In a normal flow, a platform asks for a birth date, then stores it, forwards it, or exposes it to whoever is on the other side. This app is built around the opposite idea: disclose as little as possible and still satisfy the check.

The Age Verification (AV) android app is part of the Age Verification Solution Toolbox and serves as a component that can be used by Member States, if necessary, to develop a national solution and build upon the building blocks of the toolbox.

Project Documentation, Reference implementation · eu-digital-identity-wallet/av-app-android-wallet-ui at dzpk.io

That frame explains the whole repo. It is a policy boundary expressed as software: prove eligibility, avoid identity overexposure, and leave room for national implementations to adapt the flow.

Why this repo exists

This app is a fork of the broader EUDI Android wallet reference application, but it narrows the use case to age verification. That makes it a reference implementation for the European Commission’s toolbox, not a polished consumer product.

The documentation is explicit about the limits. It is white-label, not feature complete, and it still expects Member States or publishing parties to implement their own enrollment procedures before production deployment.

The app is built like a product line, not a project

The repo’s architecture is the second surprise. It is not a single app module with a pile of screens attached. It is a modular system with feature modules, logic modules, assembly logic, and build logic working together like a controlled supply chain.

The app is assembled as a graph of smaller graphs, which keeps features isolated and the policy surface narrow.

The key idea is separation. Feature modules own user journeys. Logic modules own reusable behavior. Assembly stitches the journeys together. Build logic keeps the whole thing from drifting as the module count grows.

A close-up control room with separate drawers labeled feature, logic, assembly, and build. A conductor-like figure routes cards between them, while each drawer keeps its own lock and shape. The image explains how the repo preserves feature isolation while still assembling one app.
Modularity is not just structure here. It is how the repo keeps different teams from stepping on each other.

The assembly layer is the hidden conductor

In the codebase, the orchestration points matter. Application.kt handles app-level wiring and background work like revocation checking. MainActivity.kt acts less like a monolith and more like a router that assembles several feature graphs.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            AppTheme {
                featureOnboardingGraph()
                featureIssuanceGraph()
                presentationGraph()
            }
        }
    }
}

That pattern matters because it keeps the navigational system from becoming a single giant file. Each journey stays independently owned, but the app still feels like one product.

The security model is strict by design

The security story is not decorative. Keys are generated or retrieved from Android Keystore, authentication is tied to the user, and biometric enrollment changes can invalidate secrets. That is a strong stance for a wallet that handles identity-adjacent data.

The codebase also layers defensive controls on top of the platform. AES/GCM protects stored material, biometrics gate access, and PIN logic introduces lockout behavior so repeated guesses become expensive.

To enhance security, it is strongly recommended that the allowed PINs raise the overall security level. Sequential or easily guessable patterns (such as "135246 or "147258") should not be permitted. Additionally, it is advisable to check against a list of the most commonly used or "pwned" PINs to prevent users from choosing weak credentials.

Project Documentation, Security guidance · eu-digital-identity-wallet/av-app-android-wallet-ui at dzpk.io

That recommendation is telling. The repo assumes the threat is not theoretical. It treats identity material like a high-value secret, which is exactly the right default for a credential wallet.

Build logic is part of the architecture

The build system is unusually disciplined. Custom Gradle convention plugins keep module configuration aligned, which matters more in a multi-module wallet than it would in a small app. Consistency here is a form of control.

ConcernTypical appThis repo
Feature setupRepeated per moduleEncoded in convention plugins
Policy boundariesMostly informalSeparated across feature and logic layers
Build driftCommon as modules growReduced by shared build logic
GovernanceMostly manualPart of the architecture

That is why the build folder deserves editorial attention. In a regulated wallet, build consistency is not just convenience. It is part of how the team keeps security, naming, and dependency rules from fragmenting.

This is not a full wallet, and that’s the point

The repo is meant to be extended. It is a foundation for national implementations, not a finished deployment. That restraint is useful because it keeps the reference clean and makes the missing pieces obvious.

QuestionReference implementationProduction deployment
Who is it for?Member States and implementersEnd users
What it proves?The standards-backed flowOperational readiness
What must be added?National enrollment and hardeningMonitoring, support, policy integration
What is optimized?Reuse and clarityScale and resilience

What this repo teaches other Android teams

The transferable lesson is simple. If the product handles sensitive identity, then modularity is not an aesthetic preference. It is how you keep policy, protocol, security, and UI from collapsing into one tangled surface.

It also shows how to wrap platform APIs without leaking their complexity everywhere. Keystore, BiometricPrompt, and protocol flows sit behind abstractions that let the app stay readable even as the underlying rules stay strict.

For Android teams outside the EU context, that is the real takeaway. The repo is a lesson in how to design for selective disclosure, not just data collection.