Trust Developers
  • Get Started
  • Developing for Trust Wallet platform
    • Browser Extension
      • Ethereum & EVM chains
    • Mobile (WalletConnect)
    • Deep Linking
  • Listing new dApps
    • A Complete Guide to Listing your dApp with Trust Wallet
    • Optimizing your dApp for Trust Wallet
    • Debugging
  • Listing new assets
    • Add Asset
    • Requirements
    • Pull Request Fee
    • FAQ
    • Repository Details
    • Universal Asset ID
  • Wallet Core
    • New Blockchain Support
      • RPC / API Requirements
      • New EVM-compatible chain
    • Developing the Library
      • Contributing
      • Building
      • WalletConsole utility
      • Coverage
      • Releasing
    • Integration Guide
      • Usage Guide
      • iOS Integration Guide
      • Android Integration Guide
      • Server-Side
    • References
      • Swift API Reference
      • Kotlin API Reference
    • FAQ
  • Barz - Smart Wallet
    • Introducing Barz. TrustWallet's Smart Wallet Solution
    • Cutting Diamonds: How to make Accounts Awesome
    • Build with Trust Wallet and Barz, A Comprehensive Guide to Integrating Barz with AA SDK
Powered by GitBook
On this page
  • Prerequisites
  • Adding Library Dependency
  • Code Examples
  • Wallet Management
  • Account Address Derivation
  • Transaction Signing

Was this helpful?

  1. Wallet Core
  2. Integration Guide

Android Integration Guide

PreviousiOS Integration GuideNextServer-Side

Last updated 2 years ago

Was this helpful?

Wallet Core is available on the Android platform, through Java/JNI bindings. In this guide we show how to use it.

A sample application is available at: https://github.com/trustwallet/wallet-core/tree/master/samples/android .

Prerequisites

  • Android Studio

  • Android NDK Support plugin

Adding Library Dependency

Android releases are hosted on , It needs authentication to download packages, please checkout for more details.

We recommend to create a non-expiring and readonly token for accessing GitHub packages, and add it to local.properties of your Android Studio project locally.

Generate a token :

Add this dependency to build.gradle:

dependencies {
    implementation "com.trustwallet:wallet-core:<latest_tag>"
}

Add maven and credentials (local.properties for local or system environment variables CI)


Properties properties = new Properties()
File localProps = new File(rootDir.absolutePath, "local.properties")
if (localProps.exists()) {
    properties.load(localProps.newDataInputStream())
} else {
    println "local.properties not found"
}

allprojects {
    repositories {
        maven {
            url = uri("https://maven.pkg.github.com/trustwallet/wallet-core")
            credentials {
                username = properties.getProperty("gpr.user") as String?: System.getenv("GITHUB_USER")
                password = properties.getProperty("gpr.key") as String?: System.getenv("GITHUB_TOKEN")
            }
        }
    }
}

Code Examples

Wallet Management

First thing we need is to load JNI library

init {
    System.loadLibrary("TrustWalletCore")
}

Creating or Importing a Multi-Coin HD Wallet

val wallet = HDWallet(128, "")
val wallet = HDWallet("ripple scissors kick mammal hire column oak again sun offer wealth tomorrow wagon turn fatal", "")

Account Address Derivation

Generating the Default Address for a Coin

val addressBTC = wallet.getAddressForCoin(CoinType.BITCOIN)
val addressETH = wallet.getAddressForCoin(CoinType.ETHEREUM)
val addressBNB = wallet.getAddressForCoin(CoinType.BINANCE)

Generating an Address Using a Custom Derivation Path (Expert)

val key = wallet.getKey("m/44\'/60\'/1\'/0/0")   // m/44'/60'/1'/0/0
val address = CoinType.ETHEREUM.deriveAddress(key)

Transaction Signing

In general, when creating a new blockchain transaction, a wallet has to:

  1. Put together a transaction with relevant fields (source, target, amount, etc.)

  2. Sign the transaction, using the account private key. This is done by Wallet Core.

  3. Send to a node for broadcasting to the blockchain network.

Ethereum Transaction Signing

Code example to fill in signer input parameters, perform signing, and retrieve encoded result:

val signerInput = Ethereum.SigningInput.newBuilder().apply {
    chainId = ByteString.copyFrom(BigInteger("01").toByteArray())
    gasPrice = BigInteger("d693a400", 16).toByteString() // decimal 3600000000
    gasLimit = BigInteger("5208", 16).toByteString()     // decimal 21000
    toAddress = dummyReceiverAddress
    transaction = Ethereum.Transaction.newBuilder().apply {
       transfer = Ethereum.Transaction.Transfer.newBuilder().apply {
           amount = BigInteger("0348bca5a16000", 16).toByteString()
       }.build()
    }.build()
    privateKey = ByteString.copyFrom(secretPrivateKey.data())
}.build()
val output = AnySigner.sign(signerInput, CoinType.ETHEREUM, Ethereum.SigningOutput.parser())
println("Signed transaction: \n${signerOutput.encoded.toByteArray().toHexString()}")

In the following sections we show code examples for some common funcions. Please refer to the for detailed explanations.

Wallet Usage Guide
GitHub packages
this guide from GitHub
here