zec
/
zcash-android-wallet-sdk
mirror of https://github.com/zcash/zcash-android-wallet-sdk.git

Remove cfg(target_os="android") restriction 

The crate lives inside the Android SDK, and will only ever target
Android devices, so it's fine to simplify here.
This commit is contained in:
Jack Grigg 2019-02-07 12:56:04 +00:00
parent e99ed5bdeb
commit a9674a148b
No known key found for this signature in database
GPG Key ID: 1B8D649257DB0829
2 changed files with 327 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Cargo.toml
View File

@ -9,7 +9,10 @@ description = "JNI backend for the Android wallet SDK"
publish = false publish = false
[dependencies] [dependencies]
android_logger = "0.6"
failure = "0.1" failure = "0.1"
jni = { version = "0.10", default-features = false }
log-panics = "2.0.0"
protobuf = "2" protobuf = "2"
rand = "0.4" rand = "0.4"
rusqlite = { version = "0.15", features = ["bundled"] } rusqlite = { version = "0.15", features = ["bundled"] }
@ -39,11 +42,6 @@ rev = "89cfef8515d5d88809c485a44fdc54572b9e5666"
git = "https://github.com/str4d/librustzcash.git" git = "https://github.com/str4d/librustzcash.git"
rev = "89cfef8515d5d88809c485a44fdc54572b9e5666" rev = "89cfef8515d5d88809c485a44fdc54572b9e5666"
[target.'cfg(target_os="android")'.dependencies]
jni = { version = "0.10", default-features = false }
android_logger = "0.6"
log-panics = "2.0.0"
[lib] [lib]
name = "zcashwalletsdk" name = "zcashwalletsdk"
path = "src/main/rust/lib.rs" path = "src/main/rust/lib.rs"

658
src/main/rust/lib.rs
View File

@ -16,348 +16,338 @@ mod sql;
const SAPLING_CONSENSUS_BRANCH_ID: u32 = 0x76b8_09bb; const SAPLING_CONSENSUS_BRANCH_ID: u32 = 0x76b8_09bb;
/// JNI interface extern crate android_logger;
#[cfg(target_os = "android")] extern crate jni;
#[allow(non_snake_case)] extern crate log_panics;
pub mod android {
extern crate android_logger;
extern crate jni;
extern crate log_panics;
use log::Level; use log::Level;
use std::path::Path; use std::path::Path;
use zcash_client_backend::{ use zcash_client_backend::{
constants::{HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST, HRP_SAPLING_PAYMENT_ADDRESS_TEST}, constants::{HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST, HRP_SAPLING_PAYMENT_ADDRESS_TEST},
encoding::{ encoding::{
decode_extended_spending_key, decode_payment_address, encode_extended_spending_key, decode_extended_spending_key, decode_payment_address, encode_extended_spending_key,
}, },
note_encryption::Memo, note_encryption::Memo,
prover::LocalTxProver, prover::LocalTxProver,
}; };
use zcash_primitives::transaction::components::Amount; use zcash_primitives::transaction::components::Amount;
use zip32::{ChildIndex, ExtendedFullViewingKey, ExtendedSpendingKey}; use zip32::{ChildIndex, ExtendedFullViewingKey, ExtendedSpendingKey};
use self::android_logger::Filter; use self::android_logger::Filter;
use self::jni::objects::{JClass, JString}; use self::jni::objects::{JClass, JString};
use self::jni::sys::{ use self::jni::sys::{
jboolean, jbyteArray, jint, jlong, jobjectArray, jsize, jstring, JNI_FALSE, JNI_TRUE, jboolean, jbyteArray, jint, jlong, jobjectArray, jsize, jstring, JNI_FALSE, JNI_TRUE,
}; };
use self::jni::JNIEnv; use self::jni::JNIEnv;
use super::SAPLING_CONSENSUS_BRANCH_ID; use crate::sql::{
use crate::sql::{ get_address, get_balance, init_accounts_table, init_blocks_table, init_data_database,
get_address, get_balance, init_accounts_table, init_blocks_table, init_data_database, scan_cached_blocks, send_to_address,
scan_cached_blocks, send_to_address, };
};
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initLogs( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initLogs(_env: JNIEnv, _: JClass) {
_env: JNIEnv, android_logger::init_once(
_: JClass, Filter::default().with_min_level(Level::Trace),
) { Some("cash.z.rust.logs"),
android_logger::init_once( );
Filter::default().with_min_level(Level::Trace),
Some("cash.z.rust.logs"),
);
log_panics::init(); log_panics::init();
debug!("logs have been initialized successfully"); debug!("logs have been initialized successfully");
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initDataDb( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initDataDb(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
) -> jboolean { ) -> jboolean {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
match init_data_database(&db_data) { match init_data_database(&db_data) {
Ok(()) => JNI_TRUE, Ok(()) => JNI_TRUE,
Err(e) => { Err(e) => {
error!("Error while initializing data DB: {}", e); error!("Error while initializing data DB: {}", e);
JNI_FALSE JNI_FALSE
} }
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initAccountsTable( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initAccountsTable(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
seed: jbyteArray, seed: jbyteArray,
accounts: jint, accounts: jint,
) -> jobjectArray { ) -> jobjectArray {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let seed = env.convert_byte_array(seed).unwrap(); let seed = env.convert_byte_array(seed).unwrap();
let ret = if accounts >= 0 { let ret = if accounts >= 0 {
let master = ExtendedSpendingKey::master(&seed); let master = ExtendedSpendingKey::master(&seed);
let extsks: Vec<_> = (0..accounts as u32) let extsks: Vec<_> = (0..accounts as u32)
.map(|account| { .map(|account| {
ExtendedSpendingKey::from_path( ExtendedSpendingKey::from_path(
&master, &master,
&[ &[
ChildIndex::Hardened(32), ChildIndex::Hardened(32),
ChildIndex::Hardened(1), ChildIndex::Hardened(1),
ChildIndex::Hardened(account), ChildIndex::Hardened(account),
], ],
) )
}) })
.collect(); .collect();
let extfvks: Vec<_> = extsks let extfvks: Vec<_> = extsks
.iter() .iter()
.map(|extsk| ExtendedFullViewingKey::from(extsk)) .map(|extsk| ExtendedFullViewingKey::from(extsk))
.collect(); .collect();
match init_accounts_table(&db_data, &extfvks) { match init_accounts_table(&db_data, &extfvks) {
Ok(()) => { Ok(()) => {
// Return the ExtendedSpendingKeys for the created accounts // Return the ExtendedSpendingKeys for the created accounts
extsks extsks
} }
Err(e) => { Err(e) => {
error!("Error while initializing accounts: {}", e); error!("Error while initializing accounts: {}", e);
// Return an empty array to indicate an error // Return an empty array to indicate an error
vec![] vec![]
} }
} }
} else { } else {
error!("accounts argument must be positive"); error!("accounts argument must be positive");
// Return an empty array to indicate an error // Return an empty array to indicate an error
vec![] vec![]
}; };
let jempty = env.new_string("").expect("Couldn't create Java string!"); let jempty = env.new_string("").expect("Couldn't create Java string!");
let jret = env let jret = env
.new_object_array(ret.len() as jsize, "java/lang/String", *jempty) .new_object_array(ret.len() as jsize, "java/lang/String", *jempty)
.expect("Couldn't create Java array!"); .expect("Couldn't create Java array!");
for (i, extsk) in ret.into_iter().enumerate() { for (i, extsk) in ret.into_iter().enumerate() {
let jextsk = env let jextsk = env
.new_string(encode_extended_spending_key( .new_string(encode_extended_spending_key(
HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST, HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST,
&extsk, &extsk,
)) ))
.expect("Couldn't create Java string!"); .expect("Couldn't create Java string!");
env.set_object_array_element(jret, i as jsize, *jextsk) env.set_object_array_element(jret, i as jsize, *jextsk)
.expect("Couldn't set Java array element!"); .expect("Couldn't set Java array element!");
} }
jret jret
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initBlocksTable( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_initBlocksTable(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
height: jint, height: jint,
time: jlong, time: jlong,
sapling_tree: jbyteArray, sapling_tree: jbyteArray,
) -> jboolean { ) -> jboolean {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let time = if time >= 0 && time <= (u32::max_value() as jlong) { let time = if time >= 0 && time <= (u32::max_value() as jlong) {
time as u32 time as u32
} else { } else {
error!("time argument must fit in a u32"); error!("time argument must fit in a u32");
return JNI_FALSE; return JNI_FALSE;
}; };
let sapling_tree = env.convert_byte_array(sapling_tree).unwrap(); let sapling_tree = env.convert_byte_array(sapling_tree).unwrap();
match init_blocks_table(&db_data, height, time, &sapling_tree) { match init_blocks_table(&db_data, height, time, &sapling_tree) {
Ok(()) => JNI_TRUE, Ok(()) => JNI_TRUE,
Err(e) => { Err(e) => {
error!("Error while initializing data DB: {}", e); error!("Error while initializing data DB: {}", e);
JNI_FALSE JNI_FALSE
} }
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_getAddress( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_getAddress(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
account: jint, account: jint,
) -> jstring { ) -> jstring {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let addr = match account { let addr = match account {
acc if acc >= 0 => match get_address(&db_data, acc as u32) { acc if acc >= 0 => match get_address(&db_data, acc as u32) {
Ok(addr) => addr, Ok(addr) => addr,
Err(e) => { Err(e) => {
error!("Error while fetching address: {}", e); error!("Error while fetching address: {}", e);
// Return an empty string to indicate an error // Return an empty string to indicate an error
String::default() String::default()
} }
}, },
_ => { _ => {
error!("account argument must be positive"); error!("account argument must be positive");
// Return an empty string to indicate an error // Return an empty string to indicate an error
String::default() String::default()
} }
}; };
let output = env.new_string(addr).expect("Couldn't create Java string!"); let output = env.new_string(addr).expect("Couldn't create Java string!");
output.into_inner() output.into_inner()
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_getBalance( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_getBalance(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
account: jint, account: jint,
) -> jlong { ) -> jlong {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let account = if account >= 0 { let account = if account >= 0 {
account as u32 account as u32
} else { } else {
error!("account argument must be positive"); error!("account argument must be positive");
return -1; return -1;
}; };
match get_balance(&db_data, account) { match get_balance(&db_data, account) {
Ok(balance) => balance.0, Ok(balance) => balance.0,
Err(e) => { Err(e) => {
error!("Error while fetching balance: {}", e); error!("Error while fetching balance: {}", e);
-1 -1
} }
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_scanBlocks( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_scanBlocks(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_cache: JString, db_cache: JString,
db_data: JString, db_data: JString,
) -> jboolean { ) -> jboolean {
let db_cache: String = env let db_cache: String = env
.get_string(db_cache) .get_string(db_cache)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
match scan_cached_blocks(&db_cache, &db_data) { match scan_cached_blocks(&db_cache, &db_data) {
Ok(()) => JNI_TRUE, Ok(()) => JNI_TRUE,
Err(e) => { Err(e) => {
error!("Error while scanning blocks: {}", e); error!("Error while scanning blocks: {}", e);
JNI_FALSE JNI_FALSE
} }
} }
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_sendToAddress( pub unsafe extern "C" fn Java_cash_z_wallet_sdk_jni_JniConverter_sendToAddress(
env: JNIEnv, env: JNIEnv,
_: JClass, _: JClass,
db_data: JString, db_data: JString,
account: jint, account: jint,
extsk: JString, extsk: JString,
to: JString, to: JString,
value: jlong, value: jlong,
memo: JString, memo: JString,
spend_params: JString, spend_params: JString,
output_params: JString, output_params: JString,
) -> jlong { ) -> jlong {
let db_data: String = env let db_data: String = env
.get_string(db_data) .get_string(db_data)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let account = if account >= 0 { let account = if account >= 0 {
account as u32 account as u32
} else { } else {
error!("account argument must be positive"); error!("account argument must be positive");
return -1; return -1;
}; };
let extsk: String = env let extsk: String = env
.get_string(extsk) .get_string(extsk)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let to: String = env let to: String = env
.get_string(to) .get_string(to)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let value = Amount(value); let value = Amount(value);
let memo: String = env let memo: String = env
.get_string(memo) .get_string(memo)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let spend_params: String = env let spend_params: String = env
.get_string(spend_params) .get_string(spend_params)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let output_params: String = env let output_params: String = env
.get_string(output_params) .get_string(output_params)
.expect("Couldn't get Java string!") .expect("Couldn't get Java string!")
.into(); .into();
let extsk = let extsk = match decode_extended_spending_key(HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST, &extsk) {
match decode_extended_spending_key(HRP_SAPLING_EXTENDED_SPENDING_KEY_TEST, &extsk) { Ok(extsk) => extsk,
Ok(extsk) => extsk, Err(e) => {
Err(e) => { error!("Invalid ExtendedSpendingKey: {}", e);
error!("Invalid ExtendedSpendingKey: {}", e); return -1;
return -1; }
} };
};
let to = match decode_payment_address(HRP_SAPLING_PAYMENT_ADDRESS_TEST, &to) {
let to = match decode_payment_address(HRP_SAPLING_PAYMENT_ADDRESS_TEST, &to) { Ok(to) => to,
Ok(to) => to, Err(e) => {
Err(e) => { error!("Invalid PaymentAddress: {}", e);
error!("Invalid PaymentAddress: {}", e); return -1;
return -1; }
} };
};
let memo = match Memo::from_str(&memo) {
let memo = match Memo::from_str(&memo) { Ok(memo) => Some(memo),
Ok(memo) => Some(memo), Err(()) => {
Err(()) => { error!("Memo is too long");
error!("Memo is too long"); return -1;
return -1; }
} };
};
let prover = LocalTxProver::new(
let prover = LocalTxProver::new( Path::new(&spend_params),
Path::new(&spend_params), "8270785a1a0d0bc77196f000ee6d221c9c9894f55307bd9357c3f0105d31ca63991ab91324160d8f53e2bbd3c2633a6eb8bdf5205d822e7f3f73edac51b2b70c",
"8270785a1a0d0bc77196f000ee6d221c9c9894f55307bd9357c3f0105d31ca63991ab91324160d8f53e2bbd3c2633a6eb8bdf5205d822e7f3f73edac51b2b70c", Path::new(&output_params),
Path::new(&output_params), "657e3d38dbb5cb5e7dd2970e8b03d69b4787dd907285b5a7f0790dcc8072f60bf593b32cc2d1c030e00ff5ae64bf84c5c3beb84ddc841d48264b4a171744d028",
"657e3d38dbb5cb5e7dd2970e8b03d69b4787dd907285b5a7f0790dcc8072f60bf593b32cc2d1c030e00ff5ae64bf84c5c3beb84ddc841d48264b4a171744d028", );
);
match send_to_address(
match send_to_address( &db_data,
&db_data, SAPLING_CONSENSUS_BRANCH_ID,
SAPLING_CONSENSUS_BRANCH_ID, prover,
prover, account,
account, &extsk,
&extsk, &to,
&to, value,
value, memo,
memo, ) {
) { Ok(tx_row) => tx_row,
Ok(tx_row) => tx_row, Err(e) => {
Err(e) => { error!("Error while sending funds: {}", e);
error!("Error while sending funds: {}", e); -1
-1
}
} }
} }
} }