`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.
- This repo treats age verification as selective disclosure, so the verifier learns a threshold result instead of a full identity record.
- Its modular Kotlin structure is doing governance work, not just engineering work, because feature, logic, assembly, and build concerns stay separated.
- The security model assumes hostile conditions and backs identity data with Android Keystore, biometrics, and lockout controls.
- The project is a reference implementation, which makes its real job to define a standard shape for national implementations, not to ship a finished consumer wallet.
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.
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 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.
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.
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.
| Concern | Typical app | This repo |
|---|---|---|
| Feature setup | Repeated per module | Encoded in convention plugins |
| Policy boundaries | Mostly informal | Separated across feature and logic layers |
| Build drift | Common as modules grow | Reduced by shared build logic |
| Governance | Mostly manual | Part 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.
| Question | Reference implementation | Production deployment |
|---|---|---|
| Who is it for? | Member States and implementers | End users |
| What it proves? | The standards-backed flow | Operational readiness |
| What must be added? | National enrollment and hardening | Monitoring, support, policy integration |
| What is optimized? | Reuse and clarity | Scale 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.





