Remove sync crate, move into network crate

beacon_node/network/src/beacon_chain.rs

@@ -1,11 +1,13 @@
 use beacon_chain::BeaconChain as RawBeaconChain;
 use beacon_chain::{
     db::ClientDB, fork_choice::ForkChoice, parking_lot::RwLockReadGuard, slot_clock::SlotClock,
-    CheckPoint,
+    types::ChainSpec, CheckPoint,
 };
 
 /// The network's API to the beacon chain.
 pub trait BeaconChain: Send + Sync {
+    fn get_spec(&self) -> &ChainSpec;
+
     fn head(&self) -> RwLockReadGuard<CheckPoint>;
 
     fn finalized_head(&self) -> RwLockReadGuard<CheckPoint>;
@@ -17,6 +19,10 @@ where
     U: SlotClock,
     F: ForkChoice,
 {
+    fn get_spec(&self) -> &ChainSpec {
+        &self.spec
+    }
+
     fn head(&self) -> RwLockReadGuard<CheckPoint> {
         self.head()
     }

beacon_node/network/src/lib.rs

@@ -4,6 +4,7 @@ pub mod error;
 mod message_handler;
 mod messages;
 mod service;
+pub mod sync;
 
 pub use libp2p::NetworkConfig;
 pub use messages::NodeMessage;

beacon_node/network/src/message_handler.rs

@@ -2,16 +2,15 @@ use crate::beacon_chain::BeaconChain;
 use crate::error;
 use crate::messages::NodeMessage;
 use crate::service::NetworkMessage;
+use crate::sync::SimpleSync;
 use crossbeam_channel::{unbounded as channel, Sender};
 use futures::future;
 use futures::prelude::*;
-use libp2p::rpc;
 use libp2p::{PeerId, RPCEvent};
 use slog::debug;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
-use sync::SimpleSync;
 use types::Hash256;
 
 /// Timeout for establishing a HELLO handshake.
@@ -57,13 +56,11 @@ impl MessageHandler {
         let (handler_send, handler_recv) = channel();
 
         // Initialise sync and begin processing in thread
-        //TODO: Load genesis from BeaconChain
-        //TODO: Initialise beacon chain
-        let temp_genesis = Hash256::zero();
-
         // generate the Message handler
-        let sync = SimpleSync::new(temp_genesis);
+        let sync = SimpleSync::new(beacon_chain.clone());
+
         let mut handler = MessageHandler {
+            // TODO: The handler may not need a chain, perhaps only sync?
             chain: beacon_chain.clone(),
             sync,
             network_send,

beacon_node/network/src/sync/mod.rs

@@ -0,0 +1,11 @@
+/// Syncing for lighthouse.
+///
+/// Stores the various syncing methods for the beacon chain.
+mod simple_sync;
+
+pub use simple_sync::SimpleSync;
+
+/// Currently implemented sync methods.
+pub enum SyncMethod {
+    SimpleSync,
+}

beacon_node/network/src/sync/simple_sync.rs

@@ -0,0 +1,39 @@
+use crate::beacon_chain::BeaconChain;
+use libp2p::PeerId;
+use std::collections::HashMap;
+use std::sync::Arc;
+use types::{Epoch, Hash256, Slot};
+
+/// Keeps track of syncing information for known connected peers.
+pub struct PeerSyncInfo {
+    latest_finalized_root: Hash256,
+    latest_finalized_epoch: Epoch,
+    best_root: Hash256,
+    best_slot: Slot,
+}
+
+/// The current syncing state.
+pub enum SyncState {
+    Idle,
+    Downloading,
+    Stopped,
+}
+
+/// Simple Syncing protocol.
+//TODO: Decide for HELLO messages whether its better to keep current in RAM or build on the fly
+//when asked.
+pub struct SimpleSync {
+    known_peers: HashMap<PeerId, PeerSyncInfo>,
+    state: SyncState,
+    network_id: u8,
+}
+
+impl SimpleSync {
+    pub fn new(beacon_chain: Arc<BeaconChain>) -> Self {
+        SimpleSync {
+            known_peers: HashMap::new(),
+            state: SyncState::Idle,
+            network_id: beacon_chain.get_spec().network_id,
+        }
+    }
+}