82 lines
2.2 KiB
Rust
82 lines
2.2 KiB
Rust
extern crate types;
|
|
extern crate validator_induction;
|
|
extern crate validator_shuffling;
|
|
|
|
mod genesis;
|
|
|
|
use std::collections::HashMap;
|
|
use types::{
|
|
ActiveState,
|
|
ChainConfig,
|
|
CrystallizedState,
|
|
Hash256,
|
|
};
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum BeaconChainError {
|
|
InvalidGenesis,
|
|
DBError(String),
|
|
}
|
|
|
|
pub struct BeaconChain {
|
|
pub last_finalized_slot: Option<u64>,
|
|
pub canonical_latest_block_hash: Hash256,
|
|
pub fork_latest_block_hashes: Vec<Hash256>,
|
|
pub active_states: HashMap<Hash256, ActiveState>,
|
|
pub crystallized_states: HashMap<Hash256, CrystallizedState>,
|
|
pub config: ChainConfig,
|
|
}
|
|
|
|
impl BeaconChain {
|
|
pub fn new(config: ChainConfig)
|
|
-> Result<Self, BeaconChainError>
|
|
{
|
|
let (active_state, crystallized_state) = BeaconChain::genesis_states(&config)?;
|
|
|
|
let canonical_latest_block_hash = Hash256::zero();
|
|
let fork_latest_block_hashes = vec![];
|
|
let mut active_states = HashMap::new();
|
|
let mut crystallized_states = HashMap::new();
|
|
|
|
active_states.insert(canonical_latest_block_hash, active_state);
|
|
crystallized_states.insert(canonical_latest_block_hash, crystallized_state);
|
|
|
|
Ok(Self{
|
|
last_finalized_slot: None,
|
|
canonical_latest_block_hash,
|
|
fork_latest_block_hashes,
|
|
active_states,
|
|
crystallized_states,
|
|
config,
|
|
})
|
|
}
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use types::ValidatorRegistration;
|
|
|
|
#[test]
|
|
fn test_new_chain() {
|
|
let mut config = ChainConfig::standard();
|
|
|
|
for _ in 0..4 {
|
|
config.initial_validators.push(ValidatorRegistration::random())
|
|
}
|
|
|
|
let chain = BeaconChain::new(config.clone()).unwrap();
|
|
let (act, cry) = BeaconChain::genesis_states(&config).unwrap();
|
|
|
|
assert_eq!(chain.last_finalized_slot, None);
|
|
assert_eq!(chain.canonical_latest_block_hash, Hash256::zero());
|
|
|
|
let stored_act = chain.active_states.get(&Hash256::zero()).unwrap();
|
|
assert_eq!(act, *stored_act);
|
|
|
|
let stored_cry = chain.crystallized_states.get(&Hash256::zero()).unwrap();
|
|
assert_eq!(cry, *stored_cry);
|
|
}
|
|
}
|