249 lines
8.3 KiB
Rust
249 lines
8.3 KiB
Rust
// Tests the optimised LMD Ghost Algorithm
|
|
|
|
extern crate beacon_chain;
|
|
extern crate bls;
|
|
extern crate db;
|
|
extern crate env_logger;
|
|
extern crate fork_choice;
|
|
extern crate log;
|
|
extern crate slot_clock;
|
|
extern crate types;
|
|
extern crate yaml_rust;
|
|
|
|
pub use beacon_chain::BeaconChain;
|
|
use bls::{PublicKey, Signature};
|
|
use db::stores::{BeaconBlockStore, BeaconStateStore};
|
|
use db::MemoryDB;
|
|
use env_logger::{Builder, Env};
|
|
use fork_choice::{ForkChoice, ForkChoiceError, OptimisedLMDGhost};
|
|
use ssz::ssz_encode;
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
use std::{fs::File, io::prelude::*, path::PathBuf, str::FromStr};
|
|
use types::test_utils::{SeedableRng, TestRandom, XorShiftRng};
|
|
use types::validator_registry::get_active_validator_indices;
|
|
use types::{
|
|
BeaconBlock, BeaconBlockBody, BeaconState, ChainSpec, Deposit, DepositData, DepositInput,
|
|
Eth1Data, Hash256, Slot, Validator,
|
|
};
|
|
use yaml_rust::yaml;
|
|
|
|
// initialise a single validator and state. All blocks will reference this state root.
|
|
fn setup_inital_state(
|
|
no_validators: usize,
|
|
) -> (impl ForkChoice, Arc<BeaconBlockStore<MemoryDB>>, Hash256) {
|
|
let zero_hash = Hash256::zero();
|
|
|
|
let db = Arc::new(MemoryDB::open());
|
|
let block_store = Arc::new(BeaconBlockStore::new(db.clone()));
|
|
let state_store = Arc::new(BeaconStateStore::new(db.clone()));
|
|
|
|
// the fork choice instantiation
|
|
let optimised_lmd_ghost = OptimisedLMDGhost::new(block_store.clone(), state_store.clone());
|
|
|
|
// misc vars for setting up the state
|
|
let genesis_time = 1_550_381_159;
|
|
|
|
let latest_eth1_data = Eth1Data {
|
|
deposit_root: zero_hash.clone(),
|
|
block_hash: zero_hash.clone(),
|
|
};
|
|
|
|
let initial_validator_deposits = vec![];
|
|
|
|
/*
|
|
(0..no_validators)
|
|
.map(|_| Deposit {
|
|
branch: vec![],
|
|
index: 0,
|
|
deposit_data: DepositData {
|
|
amount: 32_000_000_000, // 32 ETH (in Gwei)
|
|
timestamp: genesis_time - 1,
|
|
deposit_input: DepositInput {
|
|
pubkey: PublicKey::default(),
|
|
withdrawal_credentials: zero_hash.clone(),
|
|
proof_of_possession: Signature::empty_signature(),
|
|
},
|
|
},
|
|
})
|
|
.collect();
|
|
*/
|
|
|
|
let spec = ChainSpec::foundation();
|
|
|
|
// create the state
|
|
let mut state = BeaconState::genesis(
|
|
genesis_time,
|
|
initial_validator_deposits,
|
|
latest_eth1_data,
|
|
&spec,
|
|
)
|
|
.unwrap();
|
|
|
|
// activate the validators
|
|
for _ in 0..no_validators {
|
|
let validator = Validator {
|
|
pubkey: PublicKey::default(),
|
|
withdrawal_credentials: zero_hash,
|
|
activation_epoch: spec.far_future_epoch,
|
|
exit_epoch: spec.far_future_epoch,
|
|
withdrawal_epoch: spec.far_future_epoch,
|
|
penalized_epoch: spec.far_future_epoch,
|
|
status_flags: None,
|
|
};
|
|
state.validator_registry.push(validator);
|
|
state.validator_balances.push(32_000_000_000);
|
|
}
|
|
|
|
let state_root = state.canonical_root();
|
|
state_store
|
|
.put(&state_root, &ssz_encode(&state)[..])
|
|
.unwrap();
|
|
|
|
println!(
|
|
"Active: {:?}",
|
|
get_active_validator_indices(
|
|
&state.validator_registry,
|
|
Slot::from(5u64).epoch(spec.EPOCH_LENGTH)
|
|
)
|
|
);
|
|
// return initialised vars
|
|
(optimised_lmd_ghost, block_store, state_root)
|
|
}
|
|
|
|
// YAML test vectors
|
|
#[test]
|
|
fn test_optimised_lmd_ghost() {
|
|
// set up logging
|
|
Builder::from_env(Env::default().default_filter_or("trace")).init();
|
|
|
|
// load the yaml
|
|
let mut file = {
|
|
let mut file_path_buf = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
|
|
file_path_buf.push("tests/fork_choice_test_vectors.yaml");
|
|
|
|
File::open(file_path_buf).unwrap()
|
|
};
|
|
|
|
let mut yaml_str = String::new();
|
|
file.read_to_string(&mut yaml_str).unwrap();
|
|
let docs = yaml::YamlLoader::load_from_str(&yaml_str).unwrap();
|
|
let doc = &docs[0];
|
|
let test_cases = doc["test_cases"].as_vec().unwrap();
|
|
|
|
// set up the test
|
|
let total_emulated_validators = 20; // the number of validators used to give weights.
|
|
let (mut fork_choice, block_store, state_root) = setup_inital_state(total_emulated_validators);
|
|
|
|
// keep a hashmap of block_id's to block_hashes (random hashes to abstract block_id)
|
|
let mut block_id_map: HashMap<String, Hash256> = HashMap::new();
|
|
// keep a list of hash to slot
|
|
let mut block_slot: HashMap<Hash256, Slot> = HashMap::new();
|
|
|
|
// default vars
|
|
let zero_hash = Hash256::zero();
|
|
let eth1_data = Eth1Data {
|
|
deposit_root: zero_hash.clone(),
|
|
block_hash: zero_hash.clone(),
|
|
};
|
|
let randao_reveal = Signature::empty_signature();
|
|
let signature = Signature::empty_signature();
|
|
let body = BeaconBlockBody {
|
|
proposer_slashings: vec![],
|
|
attester_slashings: vec![],
|
|
attestations: vec![],
|
|
deposits: vec![],
|
|
exits: vec![],
|
|
};
|
|
|
|
// process the tests
|
|
for test_case in test_cases {
|
|
// assume the block tree is given to us in order.
|
|
for block in test_case["blocks"].clone().into_vec().unwrap() {
|
|
let block_id = block["id"].as_str().unwrap().to_string();
|
|
let parent_id = block["parent"].as_str().unwrap();
|
|
|
|
// default params for genesis
|
|
let mut block_hash = zero_hash.clone();
|
|
let mut slot = Slot::from(0u64);
|
|
let mut parent_root = zero_hash;
|
|
|
|
// set the slot and parent based off the YAML. Start with genesis;
|
|
// if not the genesis, update slot and parent
|
|
if parent_id != block_id {
|
|
// generate a random hash for the block_hash
|
|
block_hash = Hash256::random();
|
|
// find the parent hash
|
|
parent_root = *block_id_map
|
|
.get(parent_id)
|
|
.expect(&format!("Parent not found: {}", parent_id));
|
|
slot = *(block_slot
|
|
.get(&parent_root)
|
|
.expect("Parent should have a slot number"))
|
|
+ 1;
|
|
}
|
|
|
|
block_id_map.insert(block_id.clone(), block_hash.clone());
|
|
|
|
// update slot mapping
|
|
block_slot.insert(block_hash, slot);
|
|
|
|
// build the BeaconBlock
|
|
let beacon_block = BeaconBlock {
|
|
slot,
|
|
parent_root,
|
|
state_root: state_root.clone(),
|
|
randao_reveal: randao_reveal.clone(),
|
|
eth1_data: eth1_data.clone(),
|
|
signature: signature.clone(),
|
|
body: body.clone(),
|
|
};
|
|
|
|
// Store the block and state.
|
|
block_store
|
|
.put(&block_hash, &ssz_encode(&beacon_block)[..])
|
|
.unwrap();
|
|
|
|
// run add block for fork choice if not genesis
|
|
if parent_id != block_id {
|
|
fork_choice.add_block(&beacon_block, &block_hash).unwrap();
|
|
}
|
|
}
|
|
|
|
// add the weights (attestations)
|
|
let mut current_validator = 0;
|
|
for id_map in test_case["weights"].clone().into_vec().unwrap() {
|
|
// get the block id and weights
|
|
for (map_id, map_weight) in id_map.as_hash().unwrap().iter() {
|
|
let id = map_id.as_str().unwrap();
|
|
let block_root = block_id_map
|
|
.get(id)
|
|
.expect(&format!("Cannot find block id: {} in weights", id));
|
|
let weight = map_weight.as_i64().unwrap();
|
|
// we assume a validator has a value 1 and add an attestation for to achieve the
|
|
// correct weight
|
|
for _ in 0..weight {
|
|
assert!(current_validator <= total_emulated_validators);
|
|
fork_choice
|
|
.add_attestation(current_validator as u64, &block_root)
|
|
.unwrap();
|
|
current_validator += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// everything is set up, run the fork choice, using genesis as the head
|
|
println!("Running fork choice");
|
|
let head = fork_choice.find_head(&zero_hash).unwrap();
|
|
|
|
let mut found_id = None;
|
|
for (id, block_hash) in block_id_map.iter() {
|
|
if *block_hash == head {
|
|
found_id = Some(id);
|
|
}
|
|
}
|
|
|
|
println!("Head Block ID: {:?}", found_id);
|
|
}
|
|
}
|