Beacon Node Syncing, Network Infrastructure and Core Services

Cargo.toml

@@ -20,6 +20,11 @@ members = [
     "eth2/utils/test_random_derive",
 	"beacon_node",
 	"beacon_node/db",
+	"beacon_node/client",
+	"beacon_node/network",
+	"beacon_node/eth2-libp2p",
+    "beacon_node/rpc",
+	"beacon_node/version",
 	"beacon_node/beacon_chain",
 	"beacon_node/beacon_chain/test_harness",
 	"protos",

beacon_node/Cargo.toml

@@ -1,25 +1,19 @@
 [package]
 name = "beacon_node"
 version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
+authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com"]
 edition = "2018"
 
 [dependencies]
-bls = { path = "../eth2/utils/bls" }
-beacon_chain = { path = "beacon_chain" }
-grpcio = { version = "0.4", default-features = false, features = ["protobuf-codec"] }
-protobuf = "2.0.2"
-protos = { path = "../protos" }
+types = { path = "../eth2/types" }
+client = { path = "client" }
+version = { path = "version" }
 clap = "2.32.0"
-db = { path = "db" }
-dirs = "1.0.3"
-futures = "0.1.23"
-fork_choice = { path = "../eth2/fork_choice" }
 slog = "^2.2.3"
-slot_clock = { path = "../eth2/utils/slot_clock" }
 slog-term = "^2.4.0"
 slog-async = "^2.3.0"
+ctrlc = { version = "3.1.1", features = ["termination"] }
+tokio = "0.1.15"
+futures = "0.1.25"
+exit-future = "0.1.3"
 state_processing = { path = "../eth2/state_processing" }
-types = { path = "../eth2/types" }
-ssz = { path = "../eth2/utils/ssz" }
-tokio = "0.1"

beacon_node/beacon_chain/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "beacon_chain"
 version = "0.1.0"
-authors = ["Paul Hauner <paul@paulhauner.com>"]
+authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com>"]
 edition = "2018"
 
 [dependencies]

beacon_node/beacon_chain/src/initialise.rs

@@ -0,0 +1,94 @@
+// Initialisation functions to generate a new BeaconChain.
+// Note: A new version of ClientTypes may need to be implemented for the lighthouse
+// testnet. These are examples. Also. there is code duplication which can/should be cleaned up.
+
+use crate::BeaconChain;
+use db::stores::{BeaconBlockStore, BeaconStateStore};
+use db::{DiskDB, MemoryDB};
+use fork_choice::BitwiseLMDGhost;
+use slot_clock::SystemTimeSlotClock;
+use ssz::TreeHash;
+use std::path::PathBuf;
+use std::sync::Arc;
+use types::test_utils::TestingBeaconStateBuilder;
+use types::{BeaconBlock, ChainSpec, Hash256};
+
+//TODO: Correct this for prod
+//TODO: Account for historical db
+pub fn initialise_beacon_chain(
+    spec: &ChainSpec,
+    db_name: Option<&PathBuf>,
+) -> Arc<BeaconChain<DiskDB, SystemTimeSlotClock, BitwiseLMDGhost<DiskDB>>> {
+    // set up the db
+    let db = Arc::new(DiskDB::open(
+        db_name.expect("Database directory must be included"),
+        None,
+    ));
+
+    let block_store = Arc::new(BeaconBlockStore::new(db.clone()));
+    let state_store = Arc::new(BeaconStateStore::new(db.clone()));
+
+    let state_builder = TestingBeaconStateBuilder::from_deterministic_keypairs(8, &spec);
+    let (genesis_state, _keypairs) = state_builder.build();
+
+    let mut genesis_block = BeaconBlock::empty(&spec);
+    genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
+
+    // Slot clock
+    let slot_clock = SystemTimeSlotClock::new(genesis_state.genesis_time, spec.seconds_per_slot)
+        .expect("Unable to load SystemTimeSlotClock");
+    // Choose the fork choice
+    let fork_choice = BitwiseLMDGhost::new(block_store.clone(), state_store.clone());
+
+    // Genesis chain
+    //TODO: Handle error correctly
+    Arc::new(
+        BeaconChain::from_genesis(
+            state_store.clone(),
+            block_store.clone(),
+            slot_clock,
+            genesis_state,
+            genesis_block,
+            spec.clone(),
+            fork_choice,
+        )
+        .expect("Terminate if beacon chain generation fails"),
+    )
+}
+
+/// Initialisation of a test beacon chain, uses an in memory db with fixed genesis time.
+pub fn initialise_test_beacon_chain(
+    spec: &ChainSpec,
+    _db_name: Option<&PathBuf>,
+) -> Arc<BeaconChain<MemoryDB, SystemTimeSlotClock, BitwiseLMDGhost<MemoryDB>>> {
+    let db = Arc::new(MemoryDB::open());
+    let block_store = Arc::new(BeaconBlockStore::new(db.clone()));
+    let state_store = Arc::new(BeaconStateStore::new(db.clone()));
+
+    let state_builder = TestingBeaconStateBuilder::from_deterministic_keypairs(8, spec);
+    let (genesis_state, _keypairs) = state_builder.build();
+
+    let mut genesis_block = BeaconBlock::empty(spec);
+    genesis_block.state_root = Hash256::from_slice(&genesis_state.hash_tree_root());
+
+    // Slot clock
+    let slot_clock = SystemTimeSlotClock::new(genesis_state.genesis_time, spec.seconds_per_slot)
+        .expect("Unable to load SystemTimeSlotClock");
+    // Choose the fork choice
+    let fork_choice = BitwiseLMDGhost::new(block_store.clone(), state_store.clone());
+
+    // Genesis chain
+    //TODO: Handle error correctly
+    Arc::new(
+        BeaconChain::from_genesis(
+            state_store.clone(),
+            block_store.clone(),
+            slot_clock,
+            genesis_state,
+            genesis_block,
+            spec.clone(),
+            fork_choice,
+        )
+        .expect("Terminate if beacon chain generation fails"),
+    )
+}

beacon_node/beacon_chain/src/lib.rs

@@ -2,8 +2,13 @@ mod attestation_aggregator;
 mod beacon_chain;
 mod checkpoint;
 mod errors;
+pub mod initialise;
 
 pub use self::beacon_chain::{BeaconChain, BlockProcessingOutcome, InvalidBlock, ValidBlock};
 pub use self::checkpoint::CheckPoint;
 pub use self::errors::BeaconChainError;
-pub use fork_choice::{ForkChoice, ForkChoiceAlgorithm, ForkChoiceError};
+pub use db;
+pub use fork_choice;
+pub use parking_lot;
+pub use slot_clock;
+pub use types;

beacon_node/client/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "client"
+version = "0.1.0"
+authors = ["Age Manning <Age@AgeManning.com>"]
+edition = "2018"
+
+[dependencies]
+beacon_chain = { path = "../beacon_chain" }
+network = { path = "../network" }
+db = { path = "../db" }
+rpc = { path = "../rpc" }
+fork_choice = { path = "../../eth2/fork_choice" }
+types = { path = "../../eth2/types" }
+slot_clock = { path = "../../eth2/utils/slot_clock" }
+error-chain = "0.12.0"
+slog = "^2.2.3"
+tokio = "0.1.15"
+clap = "2.32.0"
+dirs = "1.0.3"
+exit-future = "0.1.3"
+futures = "0.1.25"

beacon_node/client/src/client_config.rs

@@ -0,0 +1,124 @@
+use clap::ArgMatches;
+use db::DBType;
+use fork_choice::ForkChoiceAlgorithm;
+use network::NetworkConfig;
+use slog::error;
+use std::fs;
+use std::net::SocketAddr;
+use std::net::{IpAddr, Ipv4Addr};
+use std::path::PathBuf;
+use types::multiaddr::Protocol;
+use types::multiaddr::ToMultiaddr;
+use types::ChainSpec;
+
+/// Stores the client configuration for this Lighthouse instance.
+#[derive(Debug, Clone)]
+pub struct ClientConfig {
+    pub data_dir: PathBuf,
+    pub spec: ChainSpec,
+    pub net_conf: network::NetworkConfig,
+    pub fork_choice: ForkChoiceAlgorithm,
+    pub db_type: DBType,
+    pub db_name: PathBuf,
+    pub rpc_conf: rpc::RPCConfig,
+    //pub ipc_conf:
+}
+
+impl Default for ClientConfig {
+    /// Build a new lighthouse configuration from defaults.
+    fn default() -> Self {
+        let data_dir = {
+            let home = dirs::home_dir().expect("Unable to determine home dir.");
+            home.join(".lighthouse/")
+        };
+        fs::create_dir_all(&data_dir)
+            .unwrap_or_else(|_| panic!("Unable to create {:?}", &data_dir));
+
+        let default_spec = ChainSpec::lighthouse_testnet();
+        let default_net_conf = NetworkConfig::new(default_spec.boot_nodes.clone());
+
+        Self {
+            data_dir: data_dir.clone(),
+            // default to foundation for chain specs
+            spec: default_spec,
+            net_conf: default_net_conf,
+            // default to bitwise LMD Ghost
+            fork_choice: ForkChoiceAlgorithm::BitwiseLMDGhost,
+            // default to memory db for now
+            db_type: DBType::Memory,
+            // default db name for disk-based dbs
+            db_name: data_dir.join("chain.db"),
+            rpc_conf: rpc::RPCConfig::default(),
+        }
+    }
+}
+
+impl ClientConfig {
+    /// Parses the CLI arguments into a `Config` struct.
+    pub fn parse_args(args: ArgMatches, log: &slog::Logger) -> Result<Self, &'static str> {
+        let mut config = ClientConfig::default();
+
+        /* Network related arguments */
+
+        // Custom p2p listen port
+        if let Some(port_str) = args.value_of("port") {
+            if let Ok(port) = port_str.parse::<u16>() {
+                config.net_conf.listen_port = port;
+                // update the listening multiaddrs
+                for address in &mut config.net_conf.listen_addresses {
+                    address.pop();
+                    address.append(Protocol::Tcp(port));
+                }
+            } else {
+                error!(log, "Invalid port"; "port" => port_str);
+                return Err("Invalid port");
+            }
+        }
+        // Custom listening address ipv4/ipv6
+        // TODO: Handle list of addresses
+        if let Some(listen_address_str) = args.value_of("listen_address") {
+            if let Ok(listen_address) = listen_address_str.parse::<IpAddr>() {
+                let multiaddr = SocketAddr::new(listen_address, config.net_conf.listen_port)
+                    .to_multiaddr()
+                    .expect("Invalid listen address format");
+                config.net_conf.listen_addresses = vec![multiaddr];
+            } else {
+                error!(log, "Invalid IP Address"; "Address" => listen_address_str);
+                return Err("Invalid IP Address");
+            }
+        }
+
+        /* Filesystem related arguments */
+
+        // Custom datadir
+        if let Some(dir) = args.value_of("datadir") {
+            config.data_dir = PathBuf::from(dir.to_string());
+        };
+
+        /* RPC related arguments */
+
+        if args.is_present("rpc") {
+            config.rpc_conf.enabled = true;
+        }
+
+        if let Some(rpc_address) = args.value_of("rpc-address") {
+            if let Ok(listen_address) = rpc_address.parse::<Ipv4Addr>() {
+                config.rpc_conf.listen_address = listen_address;
+            } else {
+                error!(log, "Invalid RPC listen address"; "Address" => rpc_address);
+                return Err("Invalid RPC listen address");
+            }
+        }
+
+        if let Some(rpc_port) = args.value_of("rpc-port") {
+            if let Ok(port) = rpc_port.parse::<u16>() {
+                config.rpc_conf.port = port;
+            } else {
+                error!(log, "Invalid RPC port"; "port" => rpc_port);
+                return Err("Invalid RPC port");
+            }
+        }
+
+        Ok(config)
+    }
+}

beacon_node/client/src/client_types.rs

@@ -0,0 +1,49 @@
+use crate::ClientConfig;
+use beacon_chain::{
+    db::{ClientDB, DiskDB, MemoryDB},
+    fork_choice::BitwiseLMDGhost,
+    initialise,
+    slot_clock::{SlotClock, SystemTimeSlotClock},
+    BeaconChain,
+};
+use fork_choice::ForkChoice;
+
+use std::sync::Arc;
+
+pub trait ClientTypes {
+    type DB: ClientDB + 'static;
+    type SlotClock: SlotClock + 'static;
+    type ForkChoice: ForkChoice + 'static;
+
+    fn initialise_beacon_chain(
+        config: &ClientConfig,
+    ) -> Arc<BeaconChain<Self::DB, Self::SlotClock, Self::ForkChoice>>;
+}
+
+pub struct StandardClientType;
+
+impl ClientTypes for StandardClientType {
+    type DB = DiskDB;
+    type SlotClock = SystemTimeSlotClock;
+    type ForkChoice = BitwiseLMDGhost<DiskDB>;
+
+    fn initialise_beacon_chain(
+        config: &ClientConfig,
+    ) -> Arc<BeaconChain<Self::DB, Self::SlotClock, Self::ForkChoice>> {
+        initialise::initialise_beacon_chain(&config.spec, Some(&config.db_name))
+    }
+}
+
+pub struct TestingClientType;
+
+impl ClientTypes for TestingClientType {
+    type DB = MemoryDB;
+    type SlotClock = SystemTimeSlotClock;
+    type ForkChoice = BitwiseLMDGhost<MemoryDB>;
+
+    fn initialise_beacon_chain(
+        config: &ClientConfig,
+    ) -> Arc<BeaconChain<Self::DB, Self::SlotClock, Self::ForkChoice>> {
+        initialise::initialise_test_beacon_chain(&config.spec, None)
+    }
+}

beacon_node/client/src/error.rs

@@ -0,0 +1,14 @@
+// generates error types
+use network;
+
+use error_chain::{
+    error_chain, error_chain_processing, impl_error_chain_kind, impl_error_chain_processed,
+    impl_extract_backtrace,
+};
+
+error_chain! {
+   links  {
+       Network(network::error::Error, network::error::ErrorKind);
+   }
+
+}