Starts initialisation of beacon chain in the client

beacon_node/client/src/client_types.rs

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

beacon_node/client/src/lib.rs

@@ -21,31 +21,36 @@ use tokio::runtime::TaskExecutor;
 /// sub-services in multiple threads.
 pub struct Client<T: ClientTypes> {
     config: ClientConfig,
-    // beacon_chain: Arc<BeaconChain<T, U, F>>,
+    beacon_chain: Arc<BeaconChain<T::DB, T::SlotClock, T::ForkChoice>>,
     pub network: Arc<NetworkService>,
     pub exit: exit_future::Exit,
     pub exit_signal: Signal,
     log: slog::Logger,
-    phantom: PhantomData<T>,
 }
 
 impl<T: ClientTypes> Client<T> {
     /// Generate an instance of the client. Spawn and link all internal subprocesses.
     pub fn new(
         config: ClientConfig,
+        client_type: T,
         log: slog::Logger,
         executor: &TaskExecutor,
     ) -> error::Result<Self> {
         let (exit_signal, exit) = exit_future::signal();
 
-        // TODO: generate a beacon_chain service.
+        // generate a beacon chain
+        let beacon_chain = client_type.initialise_beacon_chain(&config);
 
         // Start the network service, libp2p and syncing threads
         // TODO: Add beacon_chain reference to network parameters
-        let network_config = config.net_conf.clone();
+        let network_config = &config.net_conf;
         let network_logger = log.new(o!("Service" => "Network"));
-        let (network, network_send) =
-            NetworkService::new(network_config, executor, network_logger)?;
+        let (network, network_send) = NetworkService::new(
+            beacon_chain.clone(),
+            network_config,
+            executor,
+            network_logger,
+        )?;
 
         Ok(Client {
             config,