octo
/
Zebra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove FromStr impls for orchard keys for now, pending Unifed versions of those 

Also modify the string encoding/decoding rountrip proptest to be just an exerciser of the keygen
for now.
This commit is contained in:
Deirdre Connolly 2021-04-29 00:35:24 -04:00
parent 6d4ecff24b
commit 42999b2112
3 changed files with 9 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
zebra-chain/proptest-regressions/orchard/keys/tests.txt Normal file
View File

@ -0,0 +1,7 @@
# Seeds for failure cases proptest has generated in the past. It is
# automatically read and these particular cases re-run before any
# novel cases are generated.
#
# It is recommended to check this file in to source control so that
# everyone who runs the test benefits from these saved cases.
cc 8ba80e3da74dc90c627f620bed08c47e7a13bb2e7762aad6e8c8f362237aed1b # shrinks to spending_key = SpendingKey { network: Mainnet, bytes: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] }

79
zebra-chain/src/orchard/keys.rs
View File

@ -11,11 +11,10 @@ use std::{
convert::{From, Into, TryFrom, TryInto},
fmt,
io::{self, Write},
str::FromStr,
};
use aes::Aes256;
use bech32::{self, FromBase32, ToBase32, Variant};
use bech32::{self, ToBase32, Variant};
use bitvec::prelude::*;
use fpe::ff1::{BinaryNumeralString, FF1};
use group::{Group, GroupEncoding};
@ -161,31 +160,6 @@ impl fmt::Display for SpendingKey {
}
}
impl FromStr for SpendingKey {
type Err = SerializationError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match bech32::decode(s) {
Ok((hrp, bytes, Variant::Bech32)) => {
let decoded = Vec::<u8>::from_base32(&bytes).unwrap();
let mut decoded_bytes = [0u8; 32];
decoded_bytes[..].copy_from_slice(&decoded[0..32]);
Ok(SpendingKey {
network: match hrp.as_str() {
sk_hrp::MAINNET => Network::Mainnet,
sk_hrp::TESTNET => Network::Testnet,
_ => return Err(SerializationError::Parse("unknown network")),
},
bytes: decoded_bytes,
})
}
_ => Err(SerializationError::Parse("bech32 decoding error")),
}
}
}
impl SpendingKey {
/// Generate a new `SpendingKey`.
///
@ -493,30 +467,6 @@ impl From<FullViewingKey> for IncomingViewingKey {
}
}
impl FromStr for IncomingViewingKey {
type Err = SerializationError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match bech32::decode(s) {
Ok((hrp, bytes, Variant::Bech32)) => {
let decoded = Vec::<u8>::from_base32(&bytes).unwrap();
let mut scalar_bytes = [0u8; 32];
scalar_bytes[..].copy_from_slice(&decoded[0..32]);
Ok(IncomingViewingKey {
network: match hrp.as_str() {
ivk_hrp::MAINNET => Network::Mainnet,
_ => Network::Testnet,
},
scalar: pallas::Scalar::from_bytes(&scalar_bytes).unwrap(),
})
}
_ => Err(SerializationError::Parse("bech32 decoding error")),
}
}
}
impl PartialEq<[u8; 32]> for IncomingViewingKey {
fn eq(&self, other: &[u8; 32]) -> bool {
self.scalar.to_bytes() == *other
@ -588,33 +538,6 @@ impl fmt::Display for FullViewingKey {
}
}
impl FromStr for FullViewingKey {
type Err = SerializationError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
match bech32::decode(s) {
Ok((hrp, bytes, Variant::Bech32)) => {
let mut decoded_bytes = io::Cursor::new(Vec::<u8>::from_base32(&bytes).unwrap());
let ak_bytes = decoded_bytes.read_32_bytes()?;
let nk_bytes = decoded_bytes.read_32_bytes()?;
let rivk_bytes = decoded_bytes.read_32_bytes()?;
Ok(FullViewingKey {
network: match hrp.as_str() {
fvk_hrp::MAINNET => Network::Mainnet,
_ => Network::Testnet,
},
spend_validating_key: SpendValidatingKey::from(ak_bytes),
nullifier_deriving_key: NullifierDerivingKey::from(nk_bytes),
ivk_commit_randomness: IvkCommitRandomness::try_from(rivk_bytes).unwrap(),
})
}
_ => Err(SerializationError::Parse("bech32 decoding error")),
}
}
}
impl FullViewingKey {
/// [4.2.3]: https://zips.z.cash/protocol/nu5.pdf#orchardkeycomponents
#[allow(non_snake_case)]

14
zebra-chain/src/orchard/keys/tests.rs
View File

@ -30,13 +30,9 @@ impl Arbitrary for TransmissionKey {
proptest! {
#[test]
fn string_roundtrips(spending_key in any::<SpendingKey>()) {
fn generate_keys(spending_key in any::<SpendingKey>()) {
zebra_test::init();
let sk_string = spending_key.to_string();
let spending_key_2: SpendingKey = sk_string.parse().unwrap();
prop_assert_eq![spending_key, spending_key_2];
let spend_authorizing_key = SpendAuthorizingKey::from(spending_key);
let spend_validating_key = SpendValidatingKey::from(spend_authorizing_key);
@ -50,17 +46,9 @@ proptest! {
ivk_commit_randomness,
};
let fvk_string = full_viewing_key.to_string();
let full_viewing_key_2: FullViewingKey = fvk_string.parse().unwrap();
prop_assert_eq![full_viewing_key, full_viewing_key_2];
let diversifier_key = DiversifierKey::from(full_viewing_key);
let incoming_viewing_key = IncomingViewingKey::from(full_viewing_key);
let ivk_string = incoming_viewing_key.to_string();
let incoming_viewing_key_2: IncomingViewingKey = ivk_string.parse().unwrap();
prop_assert_eq![incoming_viewing_key, incoming_viewing_key_2];
let _outgoing_viewing_key = OutgoingViewingKey::from(full_viewing_key);
let diversifier = Diversifier::from(diversifier_key);