Skip to content

Commit

Permalink
fix(owner): tests are now fuzzing the owner field
Browse files Browse the repository at this point in the history
  • Loading branch information
@davidrusu @dan-da
davidrusu authored and dan-da committed May 19, 2021
1 parent ffb5b66 commit fd81ae0
Show file tree
Hide file tree
Showing 3 changed files with 251 additions and 206 deletions.
129 changes: 82 additions & 47 deletions src/dbc.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,7 @@ mod tests {
use super::*;

use std::collections::{BTreeSet, HashMap, HashSet};
use std::iter::FromIterator;

use quickcheck_macros::quickcheck;

Expand All @@ -72,23 +73,39 @@ mod tests {
})
}

fn prepare_even_split(dbc: &Dbc, n_ways: u8) -> MintRequest {
let inputs: HashSet<_> = vec![dbc.clone()].into_iter().collect();
let input_hashes: BTreeSet<_> = inputs.iter().map(|in_dbc| in_dbc.name()).collect();

let outputs = divide(dbc.amount(), n_ways)
.enumerate()
.map(|(i, amount)| DbcContent {
parents: input_hashes.clone(),
amount,
output_number: i as u8,
owner: crate::bls_dkg_id().public_key_set,
})
.collect();
fn prepare_even_split(
dbc_owner: &bls_dkg::outcome::Outcome,
dbc: &Dbc,
n_ways: u8,
output_owner: &threshold_crypto::PublicKeySet,
) -> MintRequest {
let inputs = HashSet::from_iter(vec![dbc.clone()]);
let input_hashes = BTreeSet::from_iter(inputs.iter().map(|in_dbc| in_dbc.name()));

let outputs =
HashSet::from_iter(divide(dbc.amount(), n_ways).enumerate().map(|(i, amount)| {
DbcContent {
parents: input_hashes.clone(),
amount,
output_number: i as u8,
owner: output_owner.clone(),
}
}));

let transaction = MintTransaction { inputs, outputs };

let sig_share = dbc_owner
.secret_key_share
.sign(&transaction.blinded().hash());

let sig = dbc_owner
.public_key_set
.combine_signatures(vec![(0, &sig_share)])
.unwrap();

MintRequest {
transaction: MintTransaction { inputs, outputs },
input_ownership_proofs: HashMap::default(),
transaction,
input_ownership_proofs: HashMap::from_iter(vec![(dbc.name(), sig)]),
}
}

Expand All @@ -101,7 +118,7 @@ mod tests {
owner: crate::bls_dkg_id().public_key_set,
};

let input_content_hashes: BTreeSet<_> = vec![input_content.hash()].into_iter().collect();
let input_content_hashes = BTreeSet::from_iter(vec![input_content.hash()]);

let dbc = Dbc {
content: input_content,
Expand Down Expand Up @@ -132,54 +149,75 @@ mod tests {
) {
let amount = 100;
let genesis_owner = crate::bls_dkg_id();
let (mut genesis, genesis_dbc) = Mint::genesis(genesis_owner.public_key_set, amount);

let mint_request = prepare_even_split(&genesis_dbc, n_inputs.coerce());
let (mut genesis, genesis_dbc) =
Mint::genesis(genesis_owner.public_key_set.clone(), amount);

let input_owner = crate::bls_dkg_id();
let mint_request = prepare_even_split(
&genesis_owner,
&genesis_dbc,
n_inputs.coerce(),
&input_owner.public_key_set,
);
let (split_transaction, split_transaction_sigs) =
genesis.reissue(mint_request.clone()).unwrap();

assert_eq!(split_transaction, mint_request.transaction.blinded());

let inputs: HashSet<_> = mint_request
.transaction
.outputs
.into_iter()
.map(|content| Dbc {
let inputs = HashSet::from_iter(mint_request.transaction.outputs.into_iter().map(
|content| Dbc {
content,
transaction: split_transaction.clone(),
transaction_sigs: split_transaction_sigs.clone(),
})
.collect();
},
));

let input_hashes: BTreeSet<DbcContentHash> =
inputs.iter().map(|in_dbc| in_dbc.name()).collect();
let input_hashes = BTreeSet::from_iter(inputs.iter().map(|in_dbc| in_dbc.name()));

let content = DbcContent {
parents: input_hashes.clone(),
amount,
output_number: 0,
owner: crate::bls_dkg_id().public_key_set,
};
let outputs = vec![content].into_iter().collect();
let outputs = HashSet::from_iter(vec![content]);

let transaction = MintTransaction { inputs, outputs };
let sig_share = input_owner
.secret_key_share
.sign(&transaction.blinded().hash());

let sig = input_owner
.public_key_set
.combine_signatures(vec![(0, &sig_share)])
.unwrap();

let input_ownership_proofs = HashMap::from_iter(
transaction
.inputs
.iter()
.map(|input| (input.name(), sig.clone())),
);

let mint_request = MintRequest {
transaction: MintTransaction { inputs, outputs },
input_ownership_proofs: HashMap::default(),
transaction,
input_ownership_proofs,
};

let (transaction, transaction_sigs) = genesis.reissue(mint_request.clone()).unwrap();
assert_eq!(mint_request.transaction.blinded(), transaction);

let fuzzed_parents = input_hashes
.into_iter()
.skip(n_drop_parents.coerce()) // drop some parents
.chain(
// add some random parents
(0..n_add_random_parents.coerce())
.into_iter()
.map(|_| rand::random()),
)
.collect();
let fuzzed_parents = BTreeSet::from_iter(
input_hashes
.into_iter()
.skip(n_drop_parents.coerce()) // drop some parents
.chain(
// add some random parents
(0..n_add_random_parents.coerce())
.into_iter()
.map(|_| rand::random()),
),
);

let fuzzed_content = DbcContent {
parents: fuzzed_parents,
Expand Down Expand Up @@ -266,12 +304,9 @@ mod tests {
}
Err(Error::UnknownInput) => {
assert!(n_extra_input_sigs.coerce::<u8>() > 0);
assert!(
dbc.transaction_sigs
.keys()
.copied()
.collect::<BTreeSet<_>>()
!= dbc.transaction.inputs
assert_ne!(
BTreeSet::from_iter(dbc.transaction_sigs.keys().copied()),
dbc.transaction.inputs
);
}
Err(Error::UnrecognisedAuthority) => {
Expand Down
9 changes: 4 additions & 5 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
// under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. Please review the Licences for the specific language governing
// permissions and limitations relating to use of the SAFE Network Software.
#![allow(clippy::from_iter_instead_of_collect)]

#[cfg(test)]
use tiny_keccak::{Hasher, Sha3};
Expand Down Expand Up @@ -45,14 +46,12 @@ pub(crate) fn bls_dkg_id() -> bls_dkg::outcome::Outcome {

let mut msgs = vec![proposal];
while let Some(msg) = msgs.pop() {
println!("Processing {:?}", msg);
match key_gen.handle_message(&mut rand::thread_rng(), msg) {
Ok(response_msgs) => msgs.extend(response_msgs),
Err(e) => panic!("Error while generating BLS key: {:?}", e),
}
}

println!("After processing messages: {:?}", key_gen.phase());

let (_, outcome) = key_gen.generate_keys().unwrap();
outcome
Expand Down Expand Up @@ -136,9 +135,9 @@ mod tests {
pub struct TinyVec<T>(Vec<T>);

impl<T> TinyVec<T> {
pub fn vec(self) -> Vec<T> {
self.0
}
pub fn into_iter(self) -> impl Iterator<Item=T> {
self.0.into_iter()
}
}

impl<T: std::fmt::Debug> std::fmt::Debug for TinyVec<T> {
Expand Down

0 comments on commit fd81ae0

Please sign in to comment.