Skip to content
Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time
Sep 13, 2021
Aug 25, 2021

license @gmale Maven Central

This is a beta build and is currently under active development. Please be advised of the following:

  • This code currently is not audited by an external security auditor, use it at your own risk
  • The code has not been subjected to thorough review by engineers at the Electric Coin Company
  • We are actively changing the codebase and adding features where/when needed

🔒 Security Warnings

  • The Zcash Android Wallet SDK is experimental and a work in progress. Use it at your own risk.
  • Developers using this SDK must familiarize themselves with the current threat model, especially the known weaknesses described there.

Zcash Android SDK

This lightweight SDK connects Android to Zcash. It welds together Rust and Kotlin in a minimal way, allowing third-party Android apps to send and receive shielded transactions easily, securely and privately.



This SDK is designed to work with lightwalletd


From an app developer's perspective, this SDK will encapsulate the most complex aspects of using Zcash, freeing the developer to focus on UI and UX, rather than scanning blockchains and building commitment trees! Internally, the SDK is structured as follows:

SDK Diagram

Thankfully, the only thing an app developer has to be concerned with is the following:

SDK Diagram Developer Perspective

Back to contents


At a high level, this SDK simply helps native Android codebases connect to Zcash's Rust crypto libraries without needing to know Rust or be a Cryptographer. Think of it as welding. The SDK takes separate things and tightly bonds them together such that each can remain as idiomatic as possible. Its goal is to make it easy for an app to incorporate shielded transactions while remaining a good citizen on mobile devices.

Given all the moving parts, making things easy requires coordination. The Synchronizer provides that layer of abstraction so that the primary steps to make use of this SDK are simply:

  1. Start the Synchronizer
  2. Subscribe to wallet data

The Synchronizer takes care of

- Connecting to the light wallet server
- Downloading the latest compact blocks in a privacy-sensitive way
- Scanning and trial decrypting those blocks for shielded transactions related to the wallet
- Processing those related transactions into useful data for the UI
- Sending payments to a full node through [lightwalletd](
- Monitoring sent payments for status updates

To accomplish this, these responsibilities of the SDK are divided into separate components. Each component is coordinated by the Synchronizer, which is the thread that ties it all together.


Component Summary
LightWalletService Service used for requesting compact blocks
CompactBlockStore Stores compact blocks that have been downloaded from the LightWalletService
CompactBlockProcessor Validates and scans the compact blocks in the CompactBlockStore for transaction details
OutboundTransactionManager Creates, Submits and manages transactions for spending funds
Initializer Responsible for all setup that must happen before synchronization can begin. Loads the rust library and helps initialize databases.
DerivationTool, BirthdayTool Utilities for deriving keys, addresses and loading wallet checkpoints, called "birthdays."
RustBackend Wraps and simplifies the rust library and exposes its functionality to the Kotlin SDK

Back to contents


Add flavors for testnet v mainnet. Since productFlavors cannot start with the word 'test' we recommend:

flavorDimensions 'network'
productFlavors {
    // would rather name them "testnet" and "mainnet" but product flavor names cannot start with the word "test"
    zcashtestnet {
        dimension 'network'
        matchingFallbacks = ['zcashtestnet', 'debug']
    zcashmainnet {
        dimension 'network'
        matchingFallbacks = ['zcashmainnet', 'release']

Add the SDK dependency:

implementation ''

Start the Synchronizer


Get the wallet's address


// or alternatively


Send funds to another address

synchronizer.sendToAddress(spendingKey, zatoshi, address, memo)

Back to contents


Full working examples can be found in the demo app, covering all major functionality of the SDK. Each demo strives to be self-contained so that a developer can understand everything required for it to work. Testnet builds of the demo app will soon be available to download as github releases.


Menu Item Related Code Description
Get Private Key GetPrivateKeyFragment.kt Given a seed, display its viewing key and spending key
Get Address GetAddressFragment.kt Given a seed, display its z-addr
Get Balance GetBalanceFragment.kt Display the balance
Get Latest Height GetLatestHeightFragment.kt Given a lightwalletd server, retrieve the latest block height
Get Block GetBlockFragment.kt Given a lightwalletd server, retrieve a compact block
Get Block Range GetBlockRangeFragment.kt Given a lightwalletd server, retrieve a range of compact blocks
List Transactions ListTransactionsFragment.kt Given a seed, list all related shielded transactions
Send SendFragment.kt Send and monitor a transaction, the most complex demo

Back to contents

Compiling Sources

⚠️ Compilation is not required unless you plan to submit a patch or fork the code. Instead, it is recommended to simply add the SDK dependencies via Gradle.

In the event that you do want to compile the SDK from sources, follow these steps:

  1. Install rust
    1. If you're a macOS user with homebrew already installed
      1. brew install rustup
      2. rustup-init
  2. Then, add the android targets via:
rustup target add armv7-linux-androideabi aarch64-linux-android i686-linux-android x86_64-linux-android
  1. Clone this repo
  2. Install Android Studio and open this project via /your/path/to/zcash-android-wallet-sdk/build.gradle
  3. Open Android Studio’s SDK manager

  1. Then, install NDK 20.0.5594570 21.1.6352462 (pro tip: build.gradle -> ndkVersion defines the actual required version. Use that because this README may get out-of-date. Also note that the "Show Package Details" box in the bottom right corner must be checked in order to install specific versions of the NDK.)

  1. To build from the command line, run:
./gradlew clean assemble

// or to install in MavenLocal, set properties in Deps.kt then run

./gradlew publishToMavenLocal

This creates a build of the SDK under build/outputs/aar/ that can be used to preview functionality. For more detailed examples, see the demo app. Note that merely using the SDK does not require installing Rust or Cargo--that is only required when compiling from source.

The repo also contains a small demo application, to verify integration with the SDK. Note that by default, the demo application is configured to retrieve dependencies from artifact hosting and therefore does not rely on the local compilation of the SDK. This can be changed by publishing to maven local as described above, as local maven publications will take precedence over hosted publications in the demo app.

  1. Create an emulator if you don’t already have one (recommended target: API 29)
  2. Import the subdirectory samples/demo-app as a separate Android Studio project
  3. Select your desired build variant. Currently, we recommend zcashmainnetDebug as the testnet variants are slower to sync to current height due to a lack of checkpoints.

  1. Sync project with Gradle files, and build from the IDE. Alternatively, to build from the command line run:
./gradlew clean assembleZcashmainnetDebug

Back to contents


This project follows semantic versioning with pre-release versions. An example of a valid version number is 1.0.4-alpha11 denoting the 11th iteration of the alpha pre-release of version 1.0.4. Stable releases, such as 1.0.4 will not contain any pre-release identifiers. Pre-releases include the following, in order of stability: alpha, beta, rc. Version codes offer a numeric representation of the build name that always increases. The first six significant digits represent the major, minor and patch number (two digits each) and the last 3 significant digits represent the pre-release identifier. The first digit of the identifier signals the build type. Lastly, each new build has a higher version code than all previous builds. The following table breaks this down:

Build Types

Type Purpose Stability Audience Identifier Example Version
alpha Sandbox. For developers to verify behavior and try features. Things seen here might never go to production. Most bugs here can be ignored. Unstable: Expect bugs Internal developers 0XX 1.2.3-alpha04 (10203004)
beta Hand-off. For developers to present finished features. Bugs found here should be reported and immediately addressed, if they relate to recent changes. Unstable: Report bugs Internal stakeholders 2XX 1.2.3-beta04 (10203204)
release candidate Hardening. Final testing for an app release that we believe is ready to go live. The focus here is regression testing to ensure that new changes have not introduced instability in areas that were previously working. Stable: Hunt for bugs External testers 4XX 1.2.3-rc04 (10203404)
production Delivery. Deliver new features to end-users. Any bugs found here need to be prioritized. Some will require immediate attention but most can be worked into a future release. Stable: Prioritize bugs Public 8XX 1.2.3 (10203800)

Back to contents


A primitive example to exercise the SDK exists in this repo, under Demo App.

There's also a more comprehensive Sample Wallet.

Back to contents


Publishing instructions for maintainers of this repository can be found in

Back to contents

Known Issues

  1. During builds, a warning will be printed that says "Unable to detect AGP versions for included builds. All projects in the build should use the same AGP version." This can be safely ignored. The version under build-conventions is the same as the version used elsewhere in the application.


Native Android SDK for Zcash




No packages published