cerc-io/lighthouse
16
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Remove old abstract_chain crate

Browse Source
This commit is contained in:
Paul Hauner 2018-12-30 13:00:40 +11:00
parent 2b63ece244
commit 0ba9b86e87
No known key found for this signature in database
GPG Key ID: 303E4494BB28068C
3 changed files with 0 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
beacon_chain/abstract_chain/Cargo.toml
View File

@ -1,10 +0,0 @@
[package]
name = "abstract_chain"
version = "0.1.0"
authors = ["Paul Hauner <paul@paulhauner.com>"]
edition = "2018"
[dependencies]
hashing = { path = "../utils/hashing" }
ssz = { path = "../utils/ssz" }
types = { path = "../types" }

16
beacon_chain/abstract_chain/src/block_reader.rs
View File

@ -1,16 +0,0 @@
use types::{BeaconBlock, Hash256};
pub trait BlockReader {
fn slot(&self) -> u64;
fn parent_root(&self) -> Hash256;
}
impl BlockReader for BeaconBlock {
fn slot(&self) -> u64 {
self.slot
}
fn parent_root(&self) -> Hash256 {
self.parent_root
}
}

185
beacon_chain/abstract_chain/src/lib.rs
View File

@ -1,185 +0,0 @@
/*
* <Block><Block><Block><Block>
*/
use hashing::canonical_hash;
use ssz::{Encodable, Decodable, DecodeError, SszStream, ssz_encode};
use std::collections::{HashMap, HashSet};
use types::Hash256;
mod block_reader;
use crate::block_reader::BlockReader;
pub trait AbstractChain {
type Block;
type Hash;
fn genesis(&mut self);
fn receive_block(&mut self, block: &BlockReader) -> bool;
fn block_by_root(&self, root: &Self::Hash) -> Option<&Self::Block>;
}
pub struct TestBlock {
slot: u64,
parent_root: Hash256,
state_root: Hash256,
weight: u8,
}
impl Encodable for TestBlock {
fn ssz_append(&self, s: &mut SszStream) {
s.append(&self.slot);
s.append(&self.parent_root);
}
}
impl Decodable for TestBlock {
fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
let (slot, i) = <_>::ssz_decode(bytes, i)?;
let (parent_root, i) = <_>::ssz_decode(bytes, i)?;
let (state_root, i) = <_>::ssz_decode(bytes, i)?;
let (weight, i) = <_>::ssz_decode(bytes, i)?;
Ok((
Self {
slot,
parent_root,
state_root,
weight,
},
i,
))
}
}
impl TestBlock {
fn canonical_hash(&self) -> Hash256 {
Hash256::from(&canonical_hash(&ssz_encode(self))[..])
}
}
impl BlockReader for TestBlock {
fn slot(&self) -> u64 {
self.slot
}
fn parent_root(&self) -> Hash256 {
self.parent_root
}
}
#[derive(Clone)]
pub struct TestState {
total_weight: u64,
skipped_slots: u64,
}
impl Encodable for TestState {
fn ssz_append(&self, s: &mut SszStream) {
s.append(&self.total_weight);
s.append(&self.skipped_slots);
}
}
impl TestState {
fn canonical_hash(&self) -> Hash256 {
Hash256::from(&canonical_hash(&ssz_encode(self))[..])
}
}
impl Decodable for TestState {
fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> {
let (total_weight, i) = <_>::ssz_decode(bytes, i)?;
let (skipped_slots, i) = <_>::ssz_decode(bytes, i)?;
Ok((
Self {
total_weight,
skipped_slots,
},
i,
))
}
}
pub struct TestChain {
slot: u64,
block_store: HashMap<Hash256, TestBlock>,
state_store: HashMap<Hash256, TestState>,
leaf_nodes: HashSet<Hash256>,
canonical_leaf_node: Hash256,
}
impl AbstractChain for TestChain {
type Block = TestBlock;
type Hash = Hash256;
fn genesis(&mut self) {
let genesis_state = TestState {
total_weight: 255,
skipped_slots: 0,
};
let state_root = genesis_state.canonical_hash();
let genesis_block = TestBlock {
slot: 0,
parent_root: Hash256::zero(),
state_root: state_root.clone(),
weight: 255,
};
let block_root = genesis_block.canonical_hash();
self.block_store.insert(block_root, genesis_block);
self.state_store.insert(state_root, genesis_state);
self.leaf_nodes.insert(block_root);
self.canonical_leaf_node = block_root;
self.slot = 0;
}
fn block_by_root(&self, root: &Hash256) -> Option<&Self::Block> {
self.block_store.get(root)
}
fn receive_block(&mut self, block: &BlockReader) -> bool {
let block_hash = block.canonical_hash();
let parent_block = match self.block_by_root(&block.parent_root()) {
Some(block) => block,
None => return false
};
let slot_distance = block.slot().saturating_sub(parent_block.slot());
if slot_distance > 0 {
let mut state = self.state_store.get(&block.parent_root()).unwrap().clone();
for _ in parent_block.slot()..(block.slot() - 1) {
state.skipped_slots += 1;
}
state.total_weight += u64::from(block.weight);
let state_root = state.canonical_hash();
if state_root != block.state_root {
return false;
}
self.leaf_nodes.remove(&block.parent_root());
self.leaf_nodes.insert(block_hash);
let canonical_state = {
let canonical_block = self.block_store.get(&self.canonical_leaf_node).unwrap();
self.state_store.get(&canonical_block.state_root).unwrap()
};
// New block is canonical, chain weight is greatest.
if state.total_weight > canonical_state.total_weight {
self.canonical_leaf_node = block_hash;
}
// New block chain weight equals existing canonical block chain weight.
else if state.total_weight == canonical_state.total_weight {
// New block is canonical as hash is highest.
if block_hash > self.canonical_leaf_node {
self.canonical_leaf_node = block_hash;
}
}
true
} else {
false
}
}
}