Mobile

Rand Wallet for Android

A native Java app over the shared Rust wallet core, loaded as a native library. The spend key is encrypted under a key held by Android's Keystore, backup is switched off, and release builds speak only HTTPS.

Download 0.8.0 Build from source Source

Google Play listing pending. Until it clears review, install version 0.8.0 from the download below, or build it from source.

Built with: Java
Distributed through: Google Play, open testing first
Requires: Android 8 (API 26) or later, arm64 or x86_64
Sending: Proves on the phone, or through the RandProtocol prover

Download

Version 0.8.0

The files are attached to the v0.8.0 release on GitHub; the buttons here are links to them, and nothing is served from this site.

Open the file on the phone and allow the install when Android asks, or run adb install on it from a computer.
The package is signed with this project's own key. To check it, apksigner verify --print-certs should print the SHA-256 75:22:2E:BF:22:D3:95:80:A5:11:2A:AC:B7:EC:2E:03:93:91:07:77:96:E0:45:1D:7B:CF:E3:7E:FA:06:53:52.
Google Play signs with its own key, so when the listing is live Android will ask you to remove this copy before it installs that one. Export your key file from Settings first.

Android package (.apk)

arm64 and x86_64 · 11.9 MB

Download

rand-wallet-0.8.0-android.apk

SHA-256 400d5c4873cc70c7893a4a0bed36eecf261bd1c9bb9578c6544d8ffbf7e976d7

Check what you downloaded

SHA256SUMS

# with SHA256SUMS downloaded into the same folder as the file
shasum -a 256 -c SHA256SUMS --ignore-missing     # macOS
sha256sum -c SHA256SUMS --ignore-missing         # Linux

# or print the sum of one file and compare it with the one above
shasum -a 256 rand-wallet-0.8.0-android.apk

A matching sum says the file is the one that was published. It does not say the file was built from the source: the builds are not reproducible bit for bit yet, so if that is what you need to know, build it yourself.

Sending

Proves on the phone, or through the RandProtocol prover

On a phone with about 8 GB of memory the app proves a transfer on the device, in a foreground service with a notification while it runs, so switching apps does not stop it.

A bundle proof peaks at about 6.2 GB. On a phone with less memory Android would stop the app mid-proof, so the review step warns with the device's own numbers. The phone then uses the RandProtocol prover by default, or your own rand-prover over https (Settings → Prover), and builds the transfer while the prover makes the proof.

A device that cannot make a proof uses the RandProtocol provers by default: a few machines run by the validators (four today, under https://prover.randprotocol.org), no fee. From 0.6.9 each has its own key, which the wallet pins, and the wallet says so before the first send. The machine that proves a send receives the wallet's viewing key and a one-time salt: its operator can read the wallet's whole history, every payment received and sent, and cannot spend. The spend key never leaves your device, which makes the small authorisation proof itself. For more privacy choose your own prover in Settings → Prover, which is then always preferred; the wallet checks every proof before it submits it.

Pairing a prover, step by step: docs/prover.md.

Your keys

Where the key lives

The spend key is the wallet's one secret. There is no account and no server holding a copy: lose the key and nobody can restore it, so save it when the wallet shows it to you.

Spend key

In EncryptedSharedPreferences: AES-256-GCM under a master key that the Android Keystore holds. The viewing key is never stored; it is derived when needed.

Unlock

Biometric prompt, with the device credential as fallback, and auto-lock after the interval in Settings.

Backup

Disabled, so the vault never leaves the phone through Google's backup service.

Notes

An app-private cache of your notes and of each payment's transaction key, rebuilt by a rescan. Release builds refuse cleartext HTTP.

Also

Swap, in the app

From 0.7.1 the phone apps have the Swap screen the extensions and the desktop app have: trade RAND and tokens through the durian.market pools without leaving the wallet. The phone makes the program call's proof and the spend authorisation itself, which needs about 1.5 GB of memory, and the RandProtocol provers make the large proof. The amount you receive is exact; if the pool moves first, nothing is sent and you get a new quote.

Build from source

Or build it yourself

Build a debug APK from the clients repository and install it with adb, on a phone or on an arm64 or x86_64 emulator (API 36).
From the emulator, a node on your own computer is http://10.0.2.2:8545; debug builds allow cleartext only to that address and to localhost.

Toolchain: Rust 1.98.1, pinned in the repository, which rustup installs. The build guide covers every client from a clean machine. Source directories: android/, core/.

Rand Wallet for Android

bash

git clone --recurse-submodules https://github.com/randprotocol/clients.git && cd clients
git checkout v0.8.0 && git submodule update --init   # the release; core/vendor/fullnode @ v0.8.0 (c0878c3)
core/scripts/build-android.sh   # → android/app/src/main/jniLibs/ (JDK 17, SDK 36, NDK 27)
cd android && ./gradlew assembleDebug   # → app/build/outputs/apk/debug/app-debug.apk
adb install -r app/build/outputs/apk/debug/app-debug.apk

Every client

What it does, on every platform

Create a wallet: A spend key generated on the device, shown once for you to save, and the rand1… address derived from it. Import an existing key, or a wallet.key.json from the rand CLI; every client exports the same file.
Receive and send: Your balance is the set of notes only your key can open; the wallet scans the commitment tree to find them. A transfer of RAND or of any listed RPL token is one 4-in-4-out bundle authorised by a proof. Nobody learns the sender, the receiver, the amount or which asset moved.
Faucet: On a testnet with an open faucet, one tap mints 100 RAND into a note only you can open.
Disclose only what you choose: Copy your viewing key and open My history on RandScan to see every note you sent or received, or copy one payment's transaction key to disclose exactly that payment and nothing else. The explorer decrypts in your browser and never sends the key anywhere.

Viewing keys and transaction keys open on randscan.org.

Testnet notes

Before you send anything

Chain: The public endpoint serves chain 21, live since 12 Oct 2026 10:31 UTC (cut on fullnode v0.8.0). The wallet core vendors fullnode v0.8.0 (c0878c3) and refuses any other chain: chain 21 runs constraint set 9, so a 0.7.x wallet cannot send on it, and this release cannot send on chain 20. Keys and addresses carry over; a wallet that scanned chain 20 shows a different-chain banner once and rescans from chain 21's genesis. Bridge deposits and withdrawals keep a 0.1% fee in zUSD, which the wallet shows before you withdraw.
RPC endpoint: Settings → Network. Defaults to https://rpc.randprotocol.org; any rand-node RPC you can reach works, and a saved URL is checked before it is kept
Proving: A bundle proof peaks at about 6.2 GB of memory and takes about a minute on a laptop CPU
Status: Experimental testnet software. Not audited. RAND on the testnet carries no real value
Licence: GPL-3.0-only, like the full node crates every client links

Other clients

One wallet, every platform

The same key file, address format and rules everywhere: a wallet created here imports into any other client and into the rand CLI.