138 lines
4.7 KiB
Rust
138 lines
4.7 KiB
Rust
use crate::coinconfig::CoinConfig;
|
|
use anyhow::anyhow;
|
|
use bip39::{Language, Mnemonic, Seed};
|
|
use zcash_client_backend::address::RecipientAddress;
|
|
use zcash_client_backend::encoding::{
|
|
decode_extended_full_viewing_key, decode_extended_spending_key,
|
|
encode_extended_full_viewing_key, encode_extended_spending_key, encode_payment_address,
|
|
};
|
|
use zcash_client_backend::keys::UnifiedFullViewingKey;
|
|
use zcash_primitives::consensus::{Network, Parameters};
|
|
use zcash_primitives::zip32::{ChildIndex, ExtendedFullViewingKey, ExtendedSpendingKey};
|
|
|
|
pub fn split_key(key: &str) -> (String, String) {
|
|
let words: Vec<_> = key.split_whitespace().collect();
|
|
let len = words.len();
|
|
let (phrase, password) = if len % 3 == 1 {
|
|
// extra word
|
|
let phrase = words[0..len - 1].join(" ");
|
|
let password = words[len - 1].to_string();
|
|
(phrase, password)
|
|
} else {
|
|
(key.to_string(), String::new())
|
|
};
|
|
(phrase, password)
|
|
}
|
|
|
|
pub fn decode_key(
|
|
coin: u8,
|
|
key: &str,
|
|
index: u32,
|
|
) -> anyhow::Result<(
|
|
Option<String>,
|
|
Option<String>,
|
|
String,
|
|
String,
|
|
Option<orchard::keys::FullViewingKey>,
|
|
)> {
|
|
let c = CoinConfig::get(coin);
|
|
let network = c.chain.network();
|
|
let (phrase, password) = split_key(key);
|
|
let res = if let Ok(mnemonic) = Mnemonic::from_phrase(&phrase, Language::English) {
|
|
let (sk, ivk, pa) = derive_secret_key(network, &mnemonic, &password, index)?;
|
|
Ok((Some(key.to_string()), Some(sk), ivk, pa, None))
|
|
} else if let Ok(sk) =
|
|
decode_extended_spending_key(network.hrp_sapling_extended_spending_key(), key)
|
|
{
|
|
let (ivk, pa) = derive_viewing_key(network, &sk)?;
|
|
Ok((None, Some(key.to_string()), ivk, pa, None))
|
|
} else if let Ok(fvk) =
|
|
decode_extended_full_viewing_key(network.hrp_sapling_extended_full_viewing_key(), key)
|
|
{
|
|
let pa = derive_address(network, &fvk)?;
|
|
Ok((None, None, key.to_string(), pa, None))
|
|
} else if let Ok(ufvk) = UnifiedFullViewingKey::decode(network, key) {
|
|
let sapling_dfvk = ufvk
|
|
.sapling()
|
|
.ok_or(anyhow!("UFVK must contain a sapling key"))?;
|
|
let sapling_efvk =
|
|
ExtendedFullViewingKey::from_diversifiable_full_viewing_key(&sapling_dfvk);
|
|
let key = encode_extended_full_viewing_key(
|
|
network.hrp_sapling_extended_full_viewing_key(),
|
|
&sapling_efvk,
|
|
);
|
|
let pa = derive_address(network, &sapling_efvk)?;
|
|
let orchard_key = ufvk.orchard().cloned();
|
|
Ok((None, None, key, pa, orchard_key))
|
|
} else {
|
|
Err(anyhow::anyhow!("Not a valid key"))
|
|
};
|
|
res
|
|
}
|
|
|
|
#[allow(dead_code)] // Used by C FFI
|
|
pub fn is_valid_key(coin: u8, key: &str) -> i8 {
|
|
let c = CoinConfig::get(coin);
|
|
let network = c.chain.network();
|
|
let (phrase, _password) = split_key(key);
|
|
if Mnemonic::from_phrase(&phrase, Language::English).is_ok() {
|
|
return 0;
|
|
}
|
|
if decode_extended_spending_key(network.hrp_sapling_extended_spending_key(), key).is_ok() {
|
|
return 1;
|
|
}
|
|
if decode_extended_full_viewing_key(network.hrp_sapling_extended_full_viewing_key(), key)
|
|
.is_ok()
|
|
{
|
|
return 2;
|
|
}
|
|
if UnifiedFullViewingKey::decode(network, key).is_ok() {
|
|
return 3;
|
|
}
|
|
// TODO: Accept UA viewing key
|
|
-1
|
|
}
|
|
|
|
pub fn decode_address(coin: u8, address: &str) -> Option<RecipientAddress> {
|
|
let c = CoinConfig::get(coin);
|
|
let network = c.chain.network();
|
|
RecipientAddress::decode(network, address)
|
|
}
|
|
|
|
fn derive_secret_key(
|
|
network: &Network,
|
|
mnemonic: &Mnemonic,
|
|
password: &str,
|
|
index: u32,
|
|
) -> anyhow::Result<(String, String, String)> {
|
|
let seed = Seed::new(mnemonic, password);
|
|
let master = ExtendedSpendingKey::master(seed.as_bytes());
|
|
let path = [
|
|
ChildIndex::Hardened(32),
|
|
ChildIndex::Hardened(network.coin_type()),
|
|
ChildIndex::Hardened(index),
|
|
];
|
|
let extsk = ExtendedSpendingKey::from_path(&master, &path);
|
|
let sk = encode_extended_spending_key(network.hrp_sapling_extended_spending_key(), &extsk);
|
|
|
|
let (fvk, pa) = derive_viewing_key(network, &extsk)?;
|
|
Ok((sk, fvk, pa))
|
|
}
|
|
|
|
fn derive_viewing_key(
|
|
network: &Network,
|
|
extsk: &ExtendedSpendingKey,
|
|
) -> anyhow::Result<(String, String)> {
|
|
let fvk = extsk.to_extended_full_viewing_key();
|
|
let pa = derive_address(network, &fvk)?;
|
|
let fvk =
|
|
encode_extended_full_viewing_key(network.hrp_sapling_extended_full_viewing_key(), &fvk);
|
|
Ok((fvk, pa))
|
|
}
|
|
|
|
fn derive_address(network: &Network, fvk: &ExtendedFullViewingKey) -> anyhow::Result<String> {
|
|
let (_, payment_address) = fvk.default_address();
|
|
let address = encode_payment_address(network.hrp_sapling_payment_address(), &payment_address);
|
|
Ok(address)
|
|
}
|