Configuration updates allow for verbosity CLI flag and spec constants

beacon_node/client/src/config.rs

@@ -1,3 +1,4 @@
+use crate::Eth2Config;
 use clap::ArgMatches;
 use http_server::HttpServerConfig;
 use network::NetworkConfig;
@@ -56,8 +57,6 @@ impl Default for Config {
             log_file: PathBuf::from(""),
             db_type: "disk".to_string(),
             db_name: "chain_db".to_string(),
-            // Note: there are no default bootnodes specified.
-            // Once bootnodes are established, add them here.
             network: NetworkConfig::new(),
             rpc: rpc::RPCConfig::default(),
             http: HttpServerConfig::default(),
@@ -129,6 +128,15 @@ impl Config {
             self.data_dir = PathBuf::from(dir);
         };
 
+        if let Some(default_spec) = args.value_of("default-spec") {
+            match default_spec {
+                "mainnet" => self.spec_constants = Eth2Config::mainnet().spec_constants,
+                "minimal" => self.spec_constants = Eth2Config::minimal().spec_constants,
+                "interop" => self.spec_constants = Eth2Config::interop().spec_constants,
+                _ => {} // not supported
+            }
+        }
+
         if let Some(dir) = args.value_of("db") {
             self.db_type = dir.to_string();
         };

beacon_node/src/main.rs

@@ -193,12 +193,9 @@ fn main() {
                 .long("default-spec")
                 .value_name("TITLE")
                 .short("default-spec")
-                .help("Specifies the default eth2 spec to be used. Overridden by any spec loaded
+                .help("Specifies the default eth2 spec to be used. This will override any spec written to disk and will therefore be used by default in future instances.")
-                from disk. A spec will be written to disk after this flag is used, so it is
-                primarily used for creating eth2 spec files.")
                 .takes_value(true)
                 .possible_values(&["mainnet", "minimal", "interop"])
-                .default_value("minimal"),
         )
         .arg(
             Arg::with_name("recent-genesis")
@@ -217,7 +214,7 @@ fn main() {
                 .help("The title of the spec constants for chain config.")
                 .takes_value(true)
                 .possible_values(&["info", "debug", "trace", "warn", "error", "crit"])
-                .default_value("info"),
+                .default_value("trace"),
         )
         .arg(
             Arg::with_name("verbosity")
@@ -316,27 +313,43 @@ fn main() {
 
     let eth2_config_path = data_dir.join(ETH2_CONFIG_FILENAME);
 
-    // Attempt to load the `Eth2Config` from file.
+    // Initialise the `Eth2Config`.
     //
-    // If the file doesn't exist, create a default one depending on the CLI flags.
+    // If a CLI parameter is set, overwrite any config file present.
-    let mut eth2_config = match read_from_file::<Eth2Config>(eth2_config_path.clone()) {
+    // If a parameter is not set, use either the config file present or default to minimal.
-        Ok(Some(c)) => c,
+    let cli_config = match matches.value_of("default-spec") {
-        Ok(None) => {
+        Some("mainnet") => Some(Eth2Config::mainnet()),
-            let default = match matches.value_of("default-spec") {
+        Some("minimal") => Some(Eth2Config::minimal()),
-                Some("mainnet") => Eth2Config::mainnet(),
+        Some("interop") => Some(Eth2Config::interop()),
-                Some("minimal") => Eth2Config::minimal(),
+        _ => None,
-                _ => unreachable!(), // Guarded by slog.
     };
-            if let Err(e) = write_to_file(eth2_config_path, &default) {
+    // if cli is specified, write the new config
+    let mut eth2_config = {
+        if let Some(cli_config) = cli_config {
+            if let Err(e) = write_to_file(eth2_config_path, &cli_config) {
                 crit!(log, "Failed to write default Eth2Config to file"; "error" => format!("{:?}", e));
                 return;
             }
-            default
+            cli_config
+        } else {
+            // config not specified, read from disk
+            match read_from_file::<Eth2Config>(eth2_config_path.clone()) {
+                Ok(Some(c)) => c,
+                Ok(None) => {
+                    // set default to minimal
+                    let eth2_config = Eth2Config::minimal();
+                    if let Err(e) = write_to_file(eth2_config_path, &eth2_config) {
+                        crit!(log, "Failed to write default Eth2Config to file"; "error" => format!("{:?}", e));
+                        return;
+                    }
+                    eth2_config
                 }
                 Err(e) => {
-            crit!(log, "Failed to load/generate an Eth2Config"; "error" => format!("{:?}", e));
+                    crit!(log, "Failed to instantiate an Eth2Config"; "error" => format!("{:?}", e));
                     return;
                 }
+            }
+        }
     };
 
     // Update the eth2 config with any CLI flags.
@@ -348,6 +361,12 @@ fn main() {
         }
     };
 
+    // check to ensure the spec constants between the client and eth2_config match
+    if eth2_config.spec_constants != client_config.spec_constants {
+        crit!(log, "Specification constants do not match."; "Client Config" => format!("{}", client_config.spec_constants), "Eth2 Config" => format!("{}", eth2_config.spec_constants));
+        return;
+    }
+
     // Start the node using a `tokio` executor.
     match run::run_beacon_node(client_config, eth2_config, &log) {
         Ok(_) => {}

eth2/utils/eth2_config/src/lib.rs

@@ -37,6 +37,13 @@ impl Eth2Config {
             spec: ChainSpec::minimal(),
         }
     }
+
+    pub fn interop() -> Self {
+        Self {
+            spec_constants: "interop".to_string(),
+            spec: ChainSpec::interop(),
+        }
+    }
 }
 
 impl Eth2Config {

validator_client/eth2_config.toml

@@ -1,47 +0,0 @@
-spec_constants = "minimal"
-
-[spec]
-target_committee_size = 4
-max_indices_per_attestation = 4096
-min_per_epoch_churn_limit = 4
-churn_limit_quotient = 65536
-base_rewards_per_epoch = 5
-shuffle_round_count = 10
-deposit_contract_tree_depth = 32
-min_deposit_amount = 1000000000
-max_effective_balance = 32000000000
-ejection_balance = 16000000000
-effective_balance_increment = 1000000000
-genesis_slot = 0
-zero_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"
-bls_withdrawal_prefix_byte = "0x00"
-genesis_time = 4294967295
-seconds_per_slot = 6
-min_attestation_inclusion_delay = 2
-min_seed_lookahead = 1
-activation_exit_delay = 4
-slots_per_eth1_voting_period = 16
-slots_per_historical_root = 8192
-min_validator_withdrawability_delay = 256
-persistent_committee_period = 2048
-max_crosslink_epochs = 64
-min_epochs_to_inactivity_penalty = 4
-base_reward_quotient = 32
-whistleblowing_reward_quotient = 512
-proposer_reward_quotient = 8
-inactivity_penalty_quotient = 33554432
-min_slashing_penalty_quotient = 32
-max_proposer_slashings = 16
-max_attester_slashings = 1
-max_attestations = 128
-max_deposits = 16
-max_voluntary_exits = 16
-max_transfers = 0
-domain_beacon_proposer = 0
-domain_randao = 1
-domain_attestation = 2
-domain_deposit = 3
-domain_voluntary_exit = 4
-domain_transfer = 5
-boot_nodes = ["/ip4/127.0.0.1/tcp/9000"]
-chain_id = 2

validator_client/src/main.rs

@@ -64,14 +64,13 @@ fn main() {
                 .takes_value(true),
         )
         .arg(
-            Arg::with_name("spec-constants")
+            Arg::with_name("default-spec")
-                .long("spec-constants")
+                .long("default-spec")
                 .value_name("TITLE")
-                .short("s")
+                .short("default-spec")
-                .help("The title of the spec constants for chain config.")
+                .help("Specifies the default eth2 spec to be used. This will override any spec written to disk and will therefore be used by default in future instances.")
                 .takes_value(true)
                 .possible_values(&["mainnet", "minimal", "interop"])
-                .default_value("minimal"),
         )
         .arg(
             Arg::with_name("debug-level")
@@ -126,7 +125,7 @@ fn main() {
 
     let client_config_path = data_dir.join(CLIENT_CONFIG_FILENAME);
 
-    // Attempt to lead the `ClientConfig` from disk.
+    // Attempt to load the `ClientConfig` from disk.
     //
     // If file doesn't exist, create a new, default one.
     let mut client_config = match read_from_file::<ValidatorClientConfig>(
@@ -164,27 +163,43 @@ fn main() {
         .and_then(|s| Some(PathBuf::from(s)))
         .unwrap_or_else(|| data_dir.join(ETH2_CONFIG_FILENAME));
 
-    // Attempt to load the `Eth2Config` from file.
+    // Initialise the `Eth2Config`.
     //
-    // If the file doesn't exist, create a default one depending on the CLI flags.
+    // If a CLI parameter is set, overwrite any config file present.
-    let mut eth2_config = match read_from_file::<Eth2Config>(eth2_config_path.clone()) {
+    // If a parameter is not set, use either the config file present or default to minimal.
-        Ok(Some(c)) => c,
+    let cli_config = match matches.value_of("default-spec") {
-        Ok(None) => {
+        Some("mainnet") => Some(Eth2Config::mainnet()),
-            let default = match matches.value_of("spec-constants") {
+        Some("minimal") => Some(Eth2Config::minimal()),
-                Some("mainnet") => Eth2Config::mainnet(),
+        Some("interop") => Some(Eth2Config::interop()),
-                Some("minimal") => Eth2Config::minimal(),
+        _ => None,
-                _ => unreachable!(), // Guarded by slog.
     };
-            if let Err(e) = write_to_file(eth2_config_path, &default) {
+    // if cli is specified, write the new config
+    let mut eth2_config = {
+        if let Some(cli_config) = cli_config {
+            if let Err(e) = write_to_file(eth2_config_path, &cli_config) {
                 crit!(log, "Failed to write default Eth2Config to file"; "error" => format!("{:?}", e));
                 return;
             }
-            default
+            cli_config
+        } else {
+            // config not specified, read from disk
+            match read_from_file::<Eth2Config>(eth2_config_path.clone()) {
+                Ok(Some(c)) => c,
+                Ok(None) => {
+                    // set default to minimal
+                    let eth2_config = Eth2Config::minimal();
+                    if let Err(e) = write_to_file(eth2_config_path, &eth2_config) {
+                        crit!(log, "Failed to write default Eth2Config to file"; "error" => format!("{:?}", e));
+                        return;
+                    }
+                    eth2_config
                 }
                 Err(e) => {
                     crit!(log, "Failed to instantiate an Eth2Config"; "error" => format!("{:?}", e));
                     return;
                 }
+            }
+        }
     };
 
     // Update the eth2 config with any CLI flags.