Add flag for web3 server

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -48,7 +48,9 @@ pub enum Error {
     BackendError(String),
 }
 
-pub trait Eth1ChainBackend<T: EthSpec> {
+pub trait Eth1ChainBackend<T: EthSpec>: Sized + Send + Sync {
+    fn new(server: String) -> Result<Self>;
+
     /// Returns the `Eth1Data` that should be included in a block being produced for the given
     /// `state`.
     fn eth1_data(&self, beacon_state: &BeaconState<T>) -> Result<Eth1Data>;
@@ -68,6 +70,10 @@ pub struct InteropEth1ChainBackend<T: EthSpec> {
 }
 
 impl<T: EthSpec> Eth1ChainBackend<T> for InteropEth1ChainBackend<T> {
+    fn new(_server: String) -> Result<Self> {
+        Ok(Self::default())
+    }
+
     fn eth1_data(&self, state: &BeaconState<T>) -> Result<Eth1Data> {
         let current_epoch = state.current_epoch();
         let slots_per_voting_period = T::slots_per_eth1_voting_period() as u64;

beacon_node/beacon_chain/src/lib.rs

@@ -19,7 +19,7 @@ pub use self::beacon_chain::{
 pub use self::checkpoint::CheckPoint;
 pub use self::errors::{BeaconChainError, BlockProductionError};
 pub use beacon_chain_builder::BeaconChainBuilder;
-pub use eth1_chain::InteropEth1ChainBackend;
+pub use eth1_chain::{Eth1ChainBackend, InteropEth1ChainBackend};
 pub use lmd_ghost;
 pub use metrics::scrape_for_metrics;
 pub use parking_lot;

beacon_node/client/src/config.rs

@@ -23,6 +23,7 @@ pub struct Config {
     /// files. It can only be configured via the CLI.
     #[serde(skip)]
     pub beacon_chain_start_method: BeaconChainStartMethod,
+    pub eth1_backend_method: Eth1BackendMethod,
     pub network: network::NetworkConfig,
     pub rpc: rpc::RPCConfig,
     pub rest_api: rest_api::ApiConfig,
@@ -69,6 +70,22 @@ impl Default for BeaconChainStartMethod {
     }
 }
 
+/// Defines which Eth1 backend the client should use.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum Eth1BackendMethod {
+    /// Use the mocked eth1 backend used in interop testing
+    Interop,
+    /// Use a web3 connection to a running Eth1 node.
+    Web3 { server: String },
+}
+
+impl Default for Eth1BackendMethod {
+    fn default() -> Self {
+        Eth1BackendMethod::Interop
+    }
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -81,6 +98,7 @@ impl Default for Config {
             rest_api: <_>::default(),
             spec_constants: TESTNET_SPEC_CONSTANTS.into(),
             beacon_chain_start_method: <_>::default(),
+            eth1_backend_method: <_>::default(),
         }
     }
 }

beacon_node/client/src/lib.rs

@@ -21,14 +21,14 @@ use tokio::runtime::TaskExecutor;
 use tokio::timer::Interval;
 use types::EthSpec;
 
-pub use beacon_chain::BeaconChainTypes;
-pub use config::{BeaconChainStartMethod, Config as ClientConfig};
+pub use beacon_chain::{BeaconChainTypes, Eth1ChainBackend, InteropEth1ChainBackend};
+pub use config::{BeaconChainStartMethod, Config as ClientConfig, Eth1BackendMethod};
 pub use eth2_config::Eth2Config;
 
 #[derive(Clone)]
 pub struct ClientType<S: Store, E: EthSpec> {
-    _phantom_t: PhantomData<S>,
-    _phantom_u: PhantomData<E>,
+    _phantom_s: PhantomData<S>,
+    _phantom_e: PhantomData<E>,
 }
 
 impl<S, E> BeaconChainTypes for ClientType<S, E>
@@ -39,6 +39,7 @@ where
     type Store = S;
     type SlotClock = SystemTimeSlotClock;
     type LmdGhost = ThreadSafeReducedTree<S, E>;
+    type Eth1Chain = InteropEth1ChainBackend<E>;
     type EthSpec = E;
 }
 
@@ -168,9 +169,11 @@ where
             }
         };
 
+        let eth1_backend = T::Eth1Chain::new(String::new()).map_err(|e| format!("{:?}", e))?;
+
         let beacon_chain: Arc<BeaconChain<T>> = Arc::new(
             beacon_chain_builder
-                .build(store)
+                .build(store, eth1_backend)
                 .map_err(error::Error::from)?,
         );
 

beacon_node/src/config.rs

@@ -1,5 +1,5 @@
 use clap::ArgMatches;
-use client::{BeaconChainStartMethod, ClientConfig, Eth2Config};
+use client::{BeaconChainStartMethod, ClientConfig, Eth1BackendMethod, Eth2Config};
 use eth2_config::{read_from_file, write_to_file};
 use lighthouse_bootstrap::Bootstrapper;
 use rand::{distributions::Alphanumeric, Rng};
@@ -25,6 +25,14 @@ type Config = (ClientConfig, Eth2Config);
 pub fn get_configs(cli_args: &ArgMatches, log: &Logger) -> Result<Config> {
     let mut builder = ConfigBuilder::new(cli_args, log)?;
 
+    if let Some(server) = cli_args.value_of("eth1-server") {
+        builder.set_eth1_backend_method(Eth1BackendMethod::Web3 {
+            server: server.into(),
+        })
+    } else {
+        builder.set_eth1_backend_method(Eth1BackendMethod::Interop)
+    }
+
     match cli_args.subcommand() {
         ("testnet", Some(sub_cmd_args)) => {
             process_testnet_subcommand(&mut builder, sub_cmd_args, log)?
@@ -288,6 +296,11 @@ impl<'a> ConfigBuilder<'a> {
         self.client_config.beacon_chain_start_method = method;
     }
 
+    /// Sets the method for starting the beacon chain.
+    pub fn set_eth1_backend_method(&mut self, method: Eth1BackendMethod) {
+        self.client_config.eth1_backend_method = method;
+    }
+
     /// Import the libp2p address for `server` into the list of bootnodes in `self`.
     ///
     /// If `port` is `Some`, it is used as the port for the `Multiaddr`. If `port` is `None`,

beacon_node/src/main.rs

@@ -162,6 +162,16 @@ fn main() {
                 .takes_value(true),
         )
 
+        /*
+         * Eth1 Integration
+         */
+        .arg(
+            Arg::with_name("eth1-server")
+                .long("eth1-server")
+                .value_name("SERVER")
+                .help("Specifies the server for a web3 connection to the Eth1 chain.")
+                .takes_value(true)
+        )
         /*
          * Database parameters.
          */

beacon_node/src/run.rs

@@ -1,4 +1,7 @@
-use client::{error, notifier, BeaconChainTypes, Client, ClientConfig, ClientType, Eth2Config};
+use client::{
+    error, notifier, BeaconChainTypes, Client, ClientConfig, ClientType, Eth1BackendMethod,
+    Eth2Config,
+};
 use futures::sync::oneshot;
 use futures::Future;
 use slog::{error, info};
@@ -47,55 +50,30 @@ pub fn run_beacon_node(
         "spec_constants" => &spec_constants,
     );
 
+    macro_rules! run_client {
+        ($store: ty, $eth_spec: ty) => {
+            run::<ClientType<$store, $eth_spec>>(
+                &db_path,
+                client_config,
+                eth2_config,
+                executor,
+                runtime,
+                log,
+            )
+        };
+    }
+
+    if let Eth1BackendMethod::Web3 { .. } = client_config.eth1_backend_method {
+        return Err("Starting from web3 backend is not supported for interop.".into());
+    }
+
     match (db_type.as_str(), spec_constants.as_str()) {
-        ("disk", "minimal") => run::<ClientType<DiskStore, MinimalEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
-        ("memory", "minimal") => run::<ClientType<MemoryStore, MinimalEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
-        ("disk", "mainnet") => run::<ClientType<DiskStore, MainnetEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
-        ("memory", "mainnet") => run::<ClientType<MemoryStore, MainnetEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
-        ("disk", "interop") => run::<ClientType<DiskStore, InteropEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
-        ("memory", "interop") => run::<ClientType<MemoryStore, InteropEthSpec>>(
-            &db_path,
-            client_config,
-            eth2_config,
-            executor,
-            runtime,
-            log,
-        ),
+        ("disk", "minimal") => run_client!(DiskStore, MinimalEthSpec),
+        ("disk", "mainnet") => run_client!(DiskStore, MainnetEthSpec),
+        ("disk", "interop") => run_client!(DiskStore, InteropEthSpec),
+        ("memory", "minimal") => run_client!(MemoryStore, MinimalEthSpec),
+        ("memory", "mainnet") => run_client!(MemoryStore, MainnetEthSpec),
+        ("memory", "interop") => run_client!(MemoryStore, InteropEthSpec),
         (db_type, spec) => {
             error!(log, "Unknown runtime configuration"; "spec_constants" => spec, "db_type" => db_type);
             Err("Unknown specification and/or db_type.".into())