Mobile App

BaseID Wallet for Mobile

Your digital identity wallet on Android and iOS. Store verifiable credentials, scan QR codes, and present proofs — all from your phone.

Android

Android 8.0+ (API 26)

React Native app with native Rust crypto via UniFFI JNI bindings. Full hardware-backed key storage on supported devices.

Available Developer Preview

iOS

iOS 15+

React Native app with native Rust crypto via UniFFI Swift bindings. Secure Enclave key storage. Requires macOS + Xcode to build.

Coming Soon

Distribution

Channel	Android	iOS
Build from source	Available now	Requires macOS
Debug APK / .app	Available now	Planned
Google Play / TestFlight	Coming soon	Planned
App Store / Play Store	Planned	Planned

During developer preview, the recommended way to test is building from source or sideloading the debug APK. Store distribution will be available after security audit and compliance review.

Android Installation

Two options: sideload a pre-built APK, or build from source.

Option A: Sideload debug APK

Enable USB debugging

On your Android device, go to Settings → About phone and tap Build number 7 times to enable Developer options. Then go to Settings → Developer options and enable USB debugging.

Build and transfer the APK

git clone https://github.com/baseid-io/baseid.git
cd baseid/src/apps/wallet-mobile
npm install
bash build-apk.sh

Output: android/app/build/outputs/apk/debug/app-debug.apk

Install via ADB

Connect your device via USB and install:

# Install on connected device
adb install android/app/build/outputs/apk/debug/app-debug.apk

# Or install on emulator
adb -e install android/app/build/outputs/apk/debug/app-debug.apk

Alternatively, transfer the .apk file to your device and open it in a file manager to install. You may need to allow installation from unknown sources.

Option B: Run from source (developer mode)

Prerequisites

Install Node.js 20+, Java 17+, and Android SDK (via Android Studio or command-line tools).

# macOS
brew install node openjdk@17
brew install --cask android-studio

# Ubuntu/Debian
sudo apt install -y nodejs npm openjdk-17-jdk
# Then install Android SDK via Android Studio or sdkmanager
sdkmanager "platforms;android-34" "build-tools;34.0.0"

Clone, install, and run

git clone https://github.com/baseid-io/baseid.git
cd baseid/src/apps/wallet-mobile
npm install

# Start Metro bundler + deploy to device/emulator
npx react-native run-android

This builds and deploys to a connected device or running emulator. Metro provides hot reload during development.

Running on an emulator

If you don't have a physical device, create an Android Virtual Device:

# Create AVD (requires Android Studio or command-line tools)
sdkmanager "system-images;android-34;google_apis;x86_64"
avdmanager create avd -n baseid_test \
  -k "system-images;android-34;google_apis;x86_64"

# Launch emulator
emulator -avd baseid_test &

# Then run the app
npx react-native run-android

iOS Installation

Requires a Mac with Xcode 15+. TestFlight distribution is planned.

Prerequisites

macOS with Xcode 15+, CocoaPods, and the Rust cross-compilation toolchain.

# Install Xcode from the App Store, then:
xcode-select --install
sudo gem install cocoapods

# Install Rust iOS targets
rustup target add aarch64-apple-ios aarch64-apple-ios-sim

Build the native crypto library

# Build UniFFI static library for iOS
cd baseid/src/rust
cargo build --release --target aarch64-apple-ios -p baseid-uniffi
cargo build --release --target aarch64-apple-ios-sim -p baseid-uniffi

# Create XCFramework
xcodebuild -create-xcframework \
  -library target/aarch64-apple-ios/release/libbaseid_uniffi.a \
  -library target/aarch64-apple-ios-sim/release/libbaseid_uniffi.a \
  -output baseid_uniffi.xcframework

Run the app

cd baseid/src/apps/wallet-mobile
npm install
cd ios && pod install && cd ..
npx react-native run-ios

This launches the app in the iOS Simulator. For physical device testing, you need an Apple Developer account and a provisioning profile.

TestFlight beta: Once the iOS build is stable, we'll distribute test builds via TestFlight. Sign up for the beta program by contacting us at baseid.io/contact.

Testing the Wallet

Once installed, here's how to test the core wallet flows:

1. Set up a new wallet

Open the app. You'll see a welcome screen, then terms of service. Accept the terms and create a 6-digit PIN. The wallet generates a DID (Decentralized Identifier) and takes you to the home dashboard.

2. Receive a credential

Tap "Paste Credential" on the home screen and paste a JWT Verifiable Credential. For testing, use the BaseID Playground to issue a test credential, then copy the JWT.

3. View credential details

Go to the Credentials tab. Tap a credential to view its full details: issuer DID, subject, issuance/expiration dates, individual claims, and the raw JWT.

4. Scan a QR code

Tap "Scan QR Code" to open the camera. Scan an OID4VCI credential offer QR to receive a credential, or an OID4VP request QR to present a proof. You can also paste a URI manually.

5. Present with selective disclosure

When responding to a proof request, you'll see which attributes are requested. Toggle individual claims on or off to control exactly what you share. Required claims are marked and cannot be deselected.

6. Lock and unlock

Tap LOCK on the home screen or go to Settings → Lock Wallet. The wallet returns to the PIN entry screen. Enter your PIN to unlock.

Running Tests

# Unit tests (no device/emulator needed)
cd baseid/src/apps/wallet-mobile
npx vitest run                        # 25 tests: config, navigation, theme

# TypeScript type checking
npx tsc --noEmit

# Kotlin JVM tests (UniFFI bindings, no emulator needed)
cd baseid/src/sdk/android/test-jvm
./gradlew test                        # 21 tests: key gen, VC sign/verify

# Instrumentation tests (requires emulator or device)
cd baseid/src/apps/wallet-mobile
npx react-native run-android
# Then run Detox or manual test checklist

Features

PIN Security

6-digit PIN entry with secure key derivation (PBKDF2 + HKDF). Credentials are encrypted at rest with XChaCha20-Poly1305.

QR Code Scanning

Scan OID4VCI credential offer QR codes and OID4VP verification request QR codes using the device camera.

Selective Disclosure

Choose exactly which attributes to share in proof requests. Toggle individual claims on or off before presenting.

Multiple Formats

Supports JWT-VC, SD-JWT VC, and ISO 18013-5 mDL credential formats with format-specific display badges.

Native Crypto

Real Ed25519 and P-256 cryptography via Rust compiled to native libraries through UniFFI bindings — no JavaScript crypto.

Credential Management

View credential details, claims, expiration dates, and raw JWT. Delete individual credentials with confirmation dialog.

Architecture

The mobile wallet shares its SDK with the web wallet and browser extension. Only the crypto provider and storage adapter differ per platform:

# Shared SDK (identical across web, extension, mobile)
@baseid/wallet-core    Credential parsing, OID4VCI/VP, DID resolution
@baseid/wallet-store   Encrypted storage (AES-256-GCM, PBKDF2, HKDF)
@baseid/wallet-ui      React hooks (useWallet, useCredentials)

# Platform-specific adapters
Android:  NativeCryptoProvider (JNI → Rust)  +  AsyncStorageAdapter
iOS:      NativeCryptoProvider (FFI → Rust)  +  AsyncStorageAdapter
Web:      WasmCryptoProvider   (WASM)        +  IndexedDBAdapter
Ext:      WasmCryptoProvider   (WASM)        +  ChromeStorageAdapter

# App structure
wallet-mobile/
├── src/App.tsx           State-machine navigation
├── src/config.ts         Platform crypto + storage selection
├── src/theme.ts          Design tokens (colors, spacing, typography)
├── src/screens/          11 screens
├── src/components/       8 reusable components
└── src/hooks/            useWallet, useCredentials

Also available as a browser extension

The BaseID Wallet is available for Chrome and Firefox browsers too. Same SDK, same credential formats, different platform.

Browser Extension Try the Playground