diff --git a/lighthouse/state/transition/mod.rs b/lighthouse/state/transition/mod.rs index a79e92d06..dd8967e65 100644 --- a/lighthouse/state/transition/mod.rs +++ b/lighthouse/state/transition/mod.rs @@ -1,14 +1,9 @@ use super::super::utils::types::Hash256; -use super::chain_config::ChainConfig; -use super::shard_and_committee::ShardAndCommittee; -use super::validator_record::ValidatorRecord; mod attestation_parent_hashes; mod shuffling; -mod validator_allocation; pub use self::attestation_parent_hashes::attestation_parent_hashes; -pub use self::validator_allocation::get_new_shuffling; pub use self::shuffling::shuffle; #[derive(Debug)] diff --git a/lighthouse/state/transition/validator_allocation.rs b/lighthouse/state/transition/validator_allocation.rs deleted file mode 100644 index f425eded6..000000000 --- a/lighthouse/state/transition/validator_allocation.rs +++ /dev/null @@ -1,224 +0,0 @@ -use super::shuffle; -use super::ChainConfig; -use super::TransitionError; -use super::ValidatorRecord; -use super::ShardAndCommittee; - -pub fn get_new_shuffling( - seed: &[u8], - validators: &Vec, - dynasty: &u64, - crosslinking_shard_start: &u16, - config: &ChainConfig) - -> Result -{ - let shuffled_validator_indices = { - let mut validator_indices = active_validator_indicies(dynasty, validators); - match shuffle(seed, validator_indices) { - Ok(shuffled) => shuffled, - _ => return Err(TransitionError::InvalidInput( - String::from("Shuffle list length exceed."))) - } - }; - let shard_indices = (0_usize..config.shard_count as usize).into_iter().collect(); - let crosslinking_shard_start = *crosslinking_shard_start as usize; - let cycle_length = config.cycle_length as usize; - let min_committee_size = config.min_committee_size as usize; - generate_cycle( - &shuffled_validator_indices, - &shard_indices, - &crosslinking_shard_start, - &cycle_length, - &min_committee_size) -} - -/// Produce a vector of validators indicies where those -/// validators start and end dynasties are within the supplied -/// `dynasty`. -fn active_validator_indicies( - dynasty: &u64, - validators: &Vec) - -> Vec -{ - validators.iter() - .enumerate() - .filter_map(|(i, validator)| { - if (validator.start_dynasty >= *dynasty) & - (validator.end_dynasty < *dynasty) - { - Some(i) - } else { - None - } - }) - .collect() -} - -type DelegatedSlot = Vec; -type DelegatedCycle = Vec; - -fn generate_cycle( - validator_indices: &Vec, - shard_indices: &Vec, - crosslinking_shard_start: &usize, - cycle_length: &usize, - min_committee_size: &usize) - -> Result -{ - let validator_count = validator_indices.len(); - let shard_count = shard_indices.len(); - - let (committees_per_slot, slots_per_committee) = { - if validator_count >= cycle_length * min_committee_size { - let committees_per_slot = validator_count / cycle_length / (min_committee_size * 2) + 1; - let slots_per_committee = 1; - (committees_per_slot, slots_per_committee) - } else { - let committees_per_slot = 1; - let mut slots_per_committee = 1; - while (validator_count * slots_per_committee < cycle_length * min_committee_size) & - (slots_per_committee < *cycle_length) { - slots_per_committee = slots_per_committee * 2; - } - (committees_per_slot, slots_per_committee) - } - }; - - let cycle = validator_indices - .chunks(validator_indices.len() / *cycle_length) - .enumerate() - .map(|(i, slot_indices)| { - let shard_id_start = crosslinking_shard_start + i * committees_per_slot / slots_per_committee; - return slot_indices - .chunks(slot_indices.len() / committees_per_slot) - .enumerate() - .map(|(j, shard_indices)| { - return ShardAndCommittee{ - shard_id: ((shard_id_start + j) % shard_count) as u16, - committee: shard_indices.to_vec(), - } - }) - .collect() - }) - .collect(); - - Ok(cycle) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn generate_cycle_helper( - validator_count: &usize, - shard_count: &usize, - crosslinking_shard_start: &usize, - cycle_length: &usize, - min_committee_size: &usize) - -> (Vec, Vec, Result) - { - let validator_indices = (0_usize..*validator_count).into_iter().collect(); - let shard_indices = (0_usize..*shard_count).into_iter().collect(); - let result = generate_cycle( - &validator_indices, - &shard_indices, - &crosslinking_shard_start, - &cycle_length, - &min_committee_size); - (validator_indices, shard_indices, result) - } - - #[allow(dead_code)] - fn print_cycle(cycle: &DelegatedCycle) { - cycle.iter() - .enumerate() - .for_each(|(i, slot)| { - println!("slot {:?}", &i); - slot.iter() - .enumerate() - .for_each(|(i, sac)| { - println!("#{:?}\tshard_id={}\tcommittee.len()={}", - &i, &sac.shard_id, &sac.committee.len()) - }) - }); - } - - fn flatten_validators(cycle: &DelegatedCycle) - -> Vec - { - let mut flattened = vec![]; - for slot in cycle.iter() { - for sac in slot.iter() { - for validator in sac.committee.iter() { - flattened.push(*validator); - } - } - } - flattened - } - - fn flatten_and_dedup_shards(cycle: &DelegatedCycle) - -> Vec - { - let mut flattened = vec![]; - for slot in cycle.iter() { - for sac in slot.iter() { - flattened.push(sac.shard_id as usize); - } - } - flattened.dedup(); - flattened - } - - fn flatten_shards_in_slots(cycle: &DelegatedCycle) - -> Vec> - { - let mut shards_in_slots: Vec> = vec![]; - for slot in cycle.iter() { - let mut shards: Vec = vec![]; - for sac in slot.iter() { - shards.push(sac.shard_id as usize); - } - shards_in_slots.push(shards); - } - shards_in_slots - } - - - #[test] - fn test_generate_cycle() { - let validator_count: usize = 100; - let shard_count: usize = 10; - let crosslinking_shard_start: usize = 0; - let cycle_length: usize = 20; - let min_committee_size: usize = 10; - let (validators, shards, result) = generate_cycle_helper( - &validator_count, - &shard_count, - &crosslinking_shard_start, - &cycle_length, - &min_committee_size); - let cycle = result.unwrap(); - - let assigned_validators = flatten_validators(&cycle); - let assigned_shards = flatten_and_dedup_shards(&cycle); - let shards_in_slots = flatten_shards_in_slots(&cycle); - assert_eq!(assigned_validators, validators, "Validator assignment incorrect"); - assert_eq!(assigned_shards, shards, "Shard assignment incorrect"); - - let expected_shards_in_slots: Vec> = vec![ - vec![0], vec![0], // Each line is 2 slots.. - vec![1], vec![1], - vec![2], vec![2], - vec![3], vec![3], - vec![4], vec![4], - vec![5], vec![5], - vec![6], vec![6], - vec![7], vec![7], - vec![8], vec![8], - vec![9], vec![9], - ]; - // assert!(compare_shards_in_slots(&cycle, &expected_shards_in_slots)); - assert_eq!(expected_shards_in_slots, shards_in_slots, "Shard assignment incorrect.") - } -}