Bump version to v1.0.3 (#2024)

## Issue Addressed

NA

## Proposed Changes

- Set version to `v1.0.3`
- Run cargo update

## Additional Info

- ~~Blocked on #2008~~

Cargo.lock

@@ -361,9 +361,9 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40a0b2bb8ae20fede194e779150fe283f65a4a08461b496de546ec366b174ad9"
+checksum = "9315f8f07556761c3e48fec2e6b276004acf426e6dc068b2c2251854d65ee0fd"
 dependencies = [
  "concurrent-queue",
  "fastrand",
@@ -611,7 +611,7 @@ dependencies = [
 
 [[package]]
 name = "beacon_node"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "beacon_chain",
  "clap",
@@ -842,7 +842,7 @@ dependencies = [
 
 [[package]]
 name = "boot_node"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "beacon_node",
  "clap",
@@ -3452,9 +3452,9 @@ checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
 
 [[package]]
 name = "js-sys"
-version = "0.3.45"
+version = "0.3.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca059e81d9486668f12d455a4ea6daa600bd408134cd17e3d3fb5a32d1f016f8"
+checksum = "cf3d7383929f7c9c7c2d0fa596f325832df98c3704f2c60553080f7127a58175"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -3563,7 +3563,7 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "lcli"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "bls",
  "clap",
@@ -3956,7 +3956,7 @@ dependencies = [
 
 [[package]]
 name = "lighthouse"
-version = "1.0.2"
+version = "1.0.3"
 dependencies = [
  "account_manager",
  "account_utils",
@@ -6283,9 +6283,9 @@ dependencies = [
 
 [[package]]
 name = "slog"
-version = "2.5.2"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cc9c640a4adbfbcc11ffb95efe5aa7af7309e002adab54b185507dbf2377b99"
+checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06"
 
 [[package]]
 name = "slog-async"
@@ -6671,9 +6671,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "1.0.52"
+version = "1.0.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c1e438504729046a5cfae47f97c30d6d083c7d91d94603efdae3477fc070d4c"
+checksum = "8833e20724c24de12bbaba5ad230ea61c3eafb05b881c7c9d3cfe8638b187e68"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -7952,11 +7952,11 @@ checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.68"
+version = "0.2.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ac64ead5ea5f05873d7c12b545865ca2b8d28adfc50a49b84770a3a97265d42"
+checksum = "3cd364751395ca0f68cafb17666eee36b63077fb5ecd972bbcd74c90c4bf736e"
 dependencies = [
- "cfg-if 0.1.10",
+ "cfg-if 1.0.0",
  "serde",
  "serde_json",
  "wasm-bindgen-macro",
@@ -7964,9 +7964,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.68"
+version = "0.2.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f22b422e2a757c35a73774860af8e112bff612ce6cb604224e8e47641a9e4f68"
+checksum = "1114f89ab1f4106e5b55e688b828c0ab0ea593a1ea7c094b141b14cbaaec2d62"
 dependencies = [
  "bumpalo",
  "lazy_static",
@@ -7979,11 +7979,11 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.18"
+version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7866cab0aa01de1edf8b5d7936938a7e397ee50ce24119aef3e1eaa3b6171da"
+checksum = "1fe9756085a84584ee9457a002b7cdfe0bfff169f45d2591d8be1345a6780e35"
 dependencies = [
- "cfg-if 0.1.10",
+ "cfg-if 1.0.0",
  "js-sys",
  "wasm-bindgen",
  "web-sys",
@@ -7991,9 +7991,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.68"
+version = "0.2.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b13312a745c08c469f0b292dd2fcd6411dba5f7160f593da6ef69b64e407038"
+checksum = "7a6ac8995ead1f084a8dea1e65f194d0973800c7f571f6edd70adf06ecf77084"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -8001,9 +8001,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.68"
+version = "0.2.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f249f06ef7ee334cc3b8ff031bfc11ec99d00f34d86da7498396dc1e3b1498fe"
+checksum = "b5a48c72f299d80557c7c62e37e7225369ecc0c963964059509fbafe917c7549"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8014,15 +8014,15 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.68"
+version = "0.2.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d649a3145108d7d3fbcde896a468d1bd636791823c9921135218ad89be08307"
+checksum = "7e7811dd7f9398f14cc76efd356f98f03aa30419dea46aa810d71e819fc97158"
 
 [[package]]
 name = "wasm-bindgen-test"
-version = "0.3.18"
+version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34d1cdc8b98a557f24733d50a1199c4b0635e465eecba9c45b214544da197f64"
+checksum = "0355fa0c1f9b792a09b6dcb6a8be24d51e71e6d74972f9eb4a44c4c004d24a25"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -8034,9 +8034,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-test-macro"
-version = "0.3.18"
+version = "0.3.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8fb9c67be7439ee8ab1b7db502a49c05e51e2835b66796c705134d9b8e1a585"
+checksum = "27e07b46b98024c2ba2f9e83a10c2ef0515f057f2da299c1762a2017de80438b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -8059,9 +8059,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.45"
+version = "0.3.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bf6ef87ad7ae8008e15a355ce696bed26012b7caa21605188cfd8214ab51e2d"
+checksum = "222b1ef9334f92a21d3fb53dc3fd80f30836959a90f9274a626d7e06315ba3c3"
 dependencies = [
  "js-sys",
  "wasm-bindgen",

README.md

@@ -73,7 +73,7 @@ Sign up to the [Lighthouse Development Updates](https://mailchi.mp/3d9df0417779/
 mailing list for email notifications about releases, network status and other important information.
 
 Encrypt sensitive messages using our [PGP
-key](https://keybase.io/sigp/pgp_keys.asc?fingerprint=dcf37e025d6c9d42ea795b119e7c6cf9988604be).
+key](https://keybase.io/sigp/pgp_keys.asc?fingerprint=15e66d941f697e28f49381f426416dc3f30674b0).
 
 ## Donations
 

beacon_node/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "beacon_node"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com"]
 edition = "2018"
 

beacon_node/beacon_chain/src/eth1_chain.rs

@@ -71,23 +71,52 @@ fn get_sync_status<T: EthSpec>(
     latest_cached_block: Option<&Eth1Block>,
     head_block: Option<&Eth1Block>,
     genesis_time: u64,
-    current_slot: Slot,
+    current_slot: Option<Slot>,
     spec: &ChainSpec,
 ) -> Option<Eth1SyncStatusData> {
-    let period = T::SlotsPerEth1VotingPeriod::to_u64();
-    // Since `period` is a "constant", we assume it is set sensibly.
-    let voting_period_start_slot = (current_slot / period) * period;
-    let voting_target_timestamp = {
+    let eth1_follow_distance_seconds = spec
+        .seconds_per_eth1_block
+        .saturating_mul(spec.eth1_follow_distance);
+
+    // The voting target timestamp needs to be special-cased when we're before
+    // genesis (as defined by `current_slot == None`).
+    //
+    // For the sake of this status, when prior to genesis we want to invent some voting periods
+    // that are *before* genesis, so that we can indicate to users that we're actually adequately
+    // cached for where they are in time.
+    let voting_target_timestamp = if let Some(current_slot) = current_slot {
+        let period = T::SlotsPerEth1VotingPeriod::to_u64();
+        let voting_period_start_slot = (current_slot / period) * period;
+
         let period_start = slot_start_seconds::<T>(
             genesis_time,
             spec.milliseconds_per_slot,
             voting_period_start_slot,
         );
-        let eth1_follow_distance_seconds = spec
-            .seconds_per_eth1_block
-            .saturating_mul(spec.eth1_follow_distance);
 
         period_start.saturating_sub(eth1_follow_distance_seconds)
+    } else {
+        // The number of seconds in an eth1 voting period.
+        let voting_period_duration =
+            T::slots_per_eth1_voting_period() as u64 * (spec.milliseconds_per_slot / 1_000);
+
+        let now = SystemTime::now().duration_since(UNIX_EPOCH).ok()?.as_secs();
+
+        // The number of seconds between now and genesis.
+        let seconds_till_genesis = genesis_time.saturating_sub(now);
+
+        // Determine how many voting periods are contained in distance between
+        // now and genesis, rounding up.
+        let voting_periods_past =
+            (seconds_till_genesis + voting_period_duration - 1) / voting_period_duration;
+
+        // Return the start time of the current voting period*.
+        //
+        // *: This voting period doesn't *actually* exist, we're just using it to
+        // give useful logs prior to genesis.
+        genesis_time
+            .saturating_sub(voting_periods_past * voting_period_duration)
+            .saturating_sub(eth1_follow_distance_seconds)
     };
 
     let latest_cached_block_number = latest_cached_block.map(|b| b.number);
@@ -232,7 +261,7 @@ where
     pub fn sync_status(
         &self,
         genesis_time: u64,
-        current_slot: Slot,
+        current_slot: Option<Slot>,
         spec: &ChainSpec,
     ) -> Option<Eth1SyncStatusData> {
         get_sync_status::<E>(

beacon_node/client/src/notifier.rs

@@ -3,7 +3,7 @@ use beacon_chain::{BeaconChain, BeaconChainTypes};
 use eth2_libp2p::NetworkGlobals;
 use futures::prelude::*;
 use parking_lot::Mutex;
-use slog::{debug, error, info, warn};
+use slog::{debug, error, info, warn, Logger};
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -56,6 +56,7 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
                         "peers" => peer_count_pretty(network.connected_peers()),
                         "wait_time" => estimated_time_pretty(Some(next_slot.as_secs() as f64)),
                     );
+                    eth1_logging(&beacon_chain, &log);
                     sleep(slot_duration).await;
                 }
                 _ => break,
@@ -172,37 +173,7 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
                 );
             }
 
-            // Perform some logging about the eth1 chain
-            if let Some(eth1_chain) = beacon_chain.eth1_chain.as_ref() {
-                if let Some(status) =
-                    eth1_chain.sync_status(head_info.genesis_time, current_slot, &beacon_chain.spec)
-                {
-                    debug!(
-                        log,
-                        "Eth1 cache sync status";
-                        "eth1_head_block" => status.head_block_number,
-                        "latest_cached_block_number" => status.latest_cached_block_number,
-                        "latest_cached_timestamp" => status.latest_cached_block_timestamp,
-                        "voting_target_timestamp" => status.voting_target_timestamp,
-                        "ready" => status.lighthouse_is_cached_and_ready
-                    );
-
-                    if !status.lighthouse_is_cached_and_ready {
-                        warn!(
-                            log,
-                            "Syncing eth1 block cache";
-                            "target_timestamp" => status.voting_target_timestamp,
-                            "latest_timestamp" => status.latest_cached_block_timestamp,
-                            "msg" => "block production temporarily impaired"
-                        );
-                    }
-                } else {
-                    error!(
-                        log,
-                        "Unable to determine eth1 sync status";
-                    );
-                }
-            }
+            eth1_logging(&beacon_chain, &log);
         }
         Ok::<(), ()>(())
     };
@@ -213,6 +184,59 @@ pub fn spawn_notifier<T: BeaconChainTypes>(
     Ok(())
 }
 
+fn eth1_logging<T: BeaconChainTypes>(beacon_chain: &BeaconChain<T>, log: &Logger) {
+    let current_slot_opt = beacon_chain.slot().ok();
+
+    if let Ok(head_info) = beacon_chain.head_info() {
+        // Perform some logging about the eth1 chain
+        if let Some(eth1_chain) = beacon_chain.eth1_chain.as_ref() {
+            if let Some(status) =
+                eth1_chain.sync_status(head_info.genesis_time, current_slot_opt, &beacon_chain.spec)
+            {
+                debug!(
+                    log,
+                    "Eth1 cache sync status";
+                    "eth1_head_block" => status.head_block_number,
+                    "latest_cached_block_number" => status.latest_cached_block_number,
+                    "latest_cached_timestamp" => status.latest_cached_block_timestamp,
+                    "voting_target_timestamp" => status.voting_target_timestamp,
+                    "ready" => status.lighthouse_is_cached_and_ready
+                );
+
+                if !status.lighthouse_is_cached_and_ready {
+                    let voting_target_timestamp = status.voting_target_timestamp;
+
+                    let distance = status
+                        .latest_cached_block_timestamp
+                        .map(|latest| {
+                            voting_target_timestamp.saturating_sub(latest)
+                                / beacon_chain.spec.seconds_per_eth1_block
+                        })
+                        .map(|distance| distance.to_string())
+                        .unwrap_or_else(|| "initializing deposits".to_string());
+
+                    warn!(
+                        log,
+                        "Syncing eth1 block cache";
+                        "msg" => "sync can take longer when using remote eth1 nodes",
+                        "est_blocks_remaining" => distance,
+                    );
+                }
+            } else {
+                error!(
+                    log,
+                    "Unable to determine eth1 sync status";
+                );
+            }
+        }
+    } else {
+        error!(
+            log,
+            "Unable to get head info";
+        );
+    }
+}
+
 /// Returns the peer count, returning something helpful if it's `usize::max_value` (effectively a
 /// `None` value).
 fn peer_count_pretty(peer_count: usize) -> String {

beacon_node/eth1/src/service.rs

@@ -4,12 +4,12 @@ use crate::{
     deposit_cache::Error as DepositCacheError,
     http::{
         get_block, get_block_number, get_chain_id, get_deposit_logs_in_range, get_network_id,
-        BlockQuery, Eth1Id, Log,
+        BlockQuery, Eth1Id,
     },
     inner::{DepositUpdater, Inner},
 };
 use fallback::{Fallback, FallbackError};
-use futures::{future::TryFutureExt, stream, stream::TryStreamExt, StreamExt};
+use futures::{future::TryFutureExt, StreamExt};
 use parking_lot::{RwLock, RwLockReadGuard};
 use serde::{Deserialize, Serialize};
 use slog::{crit, debug, error, info, trace, warn, Logger};
@@ -34,7 +34,7 @@ const BLOCK_NUMBER_TIMEOUT_MILLIS: u64 = STANDARD_TIMEOUT_MILLIS;
 /// Timeout when doing an eth_getBlockByNumber call.
 const GET_BLOCK_TIMEOUT_MILLIS: u64 = STANDARD_TIMEOUT_MILLIS;
 /// Timeout when doing an eth_getLogs to read the deposit contract logs.
-const GET_DEPOSIT_LOG_TIMEOUT_MILLIS: u64 = STANDARD_TIMEOUT_MILLIS;
+const GET_DEPOSIT_LOG_TIMEOUT_MILLIS: u64 = 60_000;
 
 const WARNING_MSG: &str = "BLOCK PROPOSALS WILL FAIL WITHOUT VALID, SYNCED ETH1 CONNECTION";
 
@@ -384,8 +384,8 @@ impl Default for Config {
             block_cache_truncation: Some(4_096),
             auto_update_interval_millis: 7_000,
             blocks_per_log_query: 1_000,
-            max_log_requests_per_update: None,
-            max_blocks_per_update: None,
+            max_log_requests_per_update: Some(100),
+            max_blocks_per_update: Some(8_192),
         }
     }
 }
@@ -817,38 +817,40 @@ impl Service {
             Vec::new()
         };
 
+        let mut logs_imported: usize = 0;
         let deposit_contract_address_ref: &str = &deposit_contract_address;
-        let logs: Vec<(Range<u64>, Vec<Log>)> =
-            stream::try_unfold(block_number_chunks.into_iter(), |mut chunks| async {
-                match chunks.next() {
-                    Some(chunk) => {
-                        let chunk_ref = &chunk;
-                        endpoints
-                            .first_success(|e| async move {
-                                get_deposit_logs_in_range(
-                                    e,
-                                    deposit_contract_address_ref,
-                                    chunk_ref.clone(),
-                                    Duration::from_millis(GET_DEPOSIT_LOG_TIMEOUT_MILLIS),
-                                )
-                                .await
-                                .map_err(SingleEndpointError::GetDepositLogsFailed)
-                            })
-                            .await
-                            .map(|logs| Some(((chunk, logs), chunks)))
-                    }
-                    None => Ok(None),
-                }
-            })
-            .try_collect()
-            .await
-            .map_err(Error::FallbackError)?;
+        for block_range in block_number_chunks.into_iter() {
+            if block_range.is_empty() {
+                debug!(
+                    self.log,
+                    "No new blocks to scan for logs";
+                );
+                continue;
+            }
 
-        let mut logs_imported = 0;
-        for (block_range, log_chunk) in logs.iter() {
+            /*
+             * Step 1. Download logs.
+             */
+            let block_range_ref = &block_range;
+            let logs = endpoints
+                .first_success(|e| async move {
+                    get_deposit_logs_in_range(
+                        e,
+                        &deposit_contract_address_ref,
+                        block_range_ref.clone(),
+                        Duration::from_millis(GET_DEPOSIT_LOG_TIMEOUT_MILLIS),
+                    )
+                    .await
+                    .map_err(SingleEndpointError::GetDepositLogsFailed)
+                })
+                .await
+                .map_err(Error::FallbackError)?;
+
+            /*
+             * Step 2. Import logs to cache.
+             */
             let mut cache = self.deposits().write();
-            log_chunk
-                .iter()
+            logs.iter()
                 .map(|raw_log| {
                     raw_log.to_deposit_log(self.inner.spec()).map_err(|error| {
                         Error::FailedToParseDepositLog {
@@ -881,6 +883,12 @@ impl Service {
                 // node to choose an invalid genesis state or propose an invalid block.
                 .collect::<Result<_, _>>()?;
 
+            debug!(
+                self.log,
+                "Imported deposit logs chunk";
+                "logs" => logs.len(),
+            );
+
             cache.last_processed_block = Some(block_range.end.saturating_sub(1));
 
             metrics::set_gauge(&metrics::DEPOSIT_CACHE_LEN, cache.cache.len() as i64);
@@ -976,8 +984,9 @@ impl Service {
         } else {
             Vec::new()
         };
-        // Download the range of blocks and sequentially import them into the cache.
-        // Last processed block in deposit cache
+
+        // This value is used to prevent the block cache from importing a block that is not yet in
+        // the deposit cache.
         let latest_in_cache = self
             .inner
             .deposit_cache
@@ -990,34 +999,26 @@ impl Service {
             .filter(|x| *x <= latest_in_cache)
             .take(max_blocks_per_update)
             .collect::<Vec<_>>();
+
+        debug!(
+            self.log,
+            "Downloading eth1 blocks";
+            "first" => ?required_block_numbers.first(),
+            "last" => ?required_block_numbers.last(),
+        );
+
         // Produce a stream from the list of required block numbers and return a future that
         // consumes the it.
 
-        let eth1_blocks: Vec<Eth1Block> = stream::try_unfold(
-            required_block_numbers.into_iter(),
-            |mut block_numbers| async {
-                match block_numbers.next() {
-                    Some(block_number) => {
-                        match endpoints
-                            .first_success(|e| async move {
-                                download_eth1_block(e, self.inner.clone(), Some(block_number)).await
-                            })
-                            .await
-                        {
-                            Ok(eth1_block) => Ok(Some((eth1_block, block_numbers))),
-                            Err(e) => Err(e),
-                        }
-                    }
-                    None => Ok(None),
-                }
-            },
-        )
-        .try_collect()
-        .await
-        .map_err(Error::FallbackError)?;
-
         let mut blocks_imported = 0;
-        for eth1_block in eth1_blocks {
+        for block_number in required_block_numbers {
+            let eth1_block = endpoints
+                .first_success(|e| async move {
+                    download_eth1_block(e, self.inner.clone(), Some(block_number)).await
+                })
+                .await
+                .map_err(Error::FallbackError)?;
+
             self.inner
                 .block_cache
                 .write()

beacon_node/eth2_libp2p/src/behaviour/mod.rs

@@ -151,11 +151,19 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
     ) -> error::Result<Self> {
         let behaviour_log = log.new(o!());
 
-        let identify = Identify::new(
-            "lighthouse/libp2p".into(),
-            lighthouse_version::version_with_platform(),
-            local_key.public(),
-        );
+        let identify = if net_conf.private {
+            Identify::new(
+                "".into(),
+                "".into(),
+                local_key.public(), // Still send legitimate public key
+            )
+        } else {
+            Identify::new(
+                "lighthouse/libp2p".into(),
+                lighthouse_version::version_with_platform(),
+                local_key.public(),
+            )
+        };
 
         let enr_fork_id = network_globals
             .local_enr()
@@ -198,7 +206,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
             current_slot,
         )?;
 
-        trace!(behaviour_log, "Using peer score params"; "params" => format!("{:?}", params));
+        trace!(behaviour_log, "Using peer score params"; "params" => ?params);
 
         let update_gossipsub_scores = tokio::time::interval(params.decay_interval);
 
@@ -241,9 +249,9 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         debug!(self.log, "Updating gossipsub score parameters";
             "active_validators" => active_validators);
         trace!(self.log, "Updated gossipsub score parameters";
-            "beacon_block_params" => format!("{:?}", beacon_block_params),
-            "beacon_aggregate_proof_params" => format!("{:?}", beacon_aggregate_proof_params),
-            "beacon_attestation_subnet_params" => format!("{:?}", beacon_attestation_subnet_params),
+            "beacon_block_params" => ?beacon_block_params,
+            "beacon_aggregate_proof_params" => ?beacon_aggregate_proof_params,
+            "beacon_attestation_subnet_params" => ?beacon_attestation_subnet_params,
         );
 
         self.gossipsub
@@ -341,11 +349,11 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
 
         match self.gossipsub.subscribe(&topic) {
             Err(_) => {
-                warn!(self.log, "Failed to subscribe to topic"; "topic" => topic.to_string());
+                warn!(self.log, "Failed to subscribe to topic"; "topic" => %topic);
                 false
             }
             Ok(v) => {
-                debug!(self.log, "Subscribed to topic"; "topic" => topic.to_string());
+                debug!(self.log, "Subscribed to topic"; "topic" => %topic);
                 v
             }
         }
@@ -364,11 +372,11 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
 
         match self.gossipsub.unsubscribe(&topic) {
             Err(_) => {
-                warn!(self.log, "Failed to unsubscribe from topic"; "topic" => topic.to_string());
+                warn!(self.log, "Failed to unsubscribe from topic"; "topic" => %topic);
                 false
             }
             Ok(v) => {
-                debug!(self.log, "Unsubscribed to topic"; "topic" => topic.to_string());
+                debug!(self.log, "Unsubscribed to topic"; "topic" => %topic);
                 v
             }
         }
@@ -382,7 +390,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                     Ok(message_data) => {
                         if let Err(e) = self.gossipsub.publish(topic.clone().into(), message_data) {
                             slog::warn!(self.log, "Could not publish message";
-                                        "error" => format!("{:?}", e));
+                                        "error" => ?e);
 
                             // add to metrics
                             match topic.kind() {
@@ -424,7 +432,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
             propagation_source,
             validation_result,
         ) {
-            warn!(self.log, "Failed to report message validation"; "message_id" => message_id.to_string(), "peer_id" => propagation_source.to_string(), "error" => format!("{:?}", e));
+            warn!(self.log, "Failed to report message validation"; "message_id" => %message_id, "peer_id" => %propagation_source, "error" => ?e);
         }
     }
 
@@ -565,7 +573,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         let ping = crate::rpc::Ping {
             data: self.network_globals.local_metadata.read().seq_number,
         };
-        trace!(self.log, "Sending Ping"; "request_id" => id, "peer_id" => peer_id.to_string());
+        trace!(self.log, "Sending Ping"; "request_id" => id, "peer_id" => %peer_id);
 
         self.eth2_rpc
             .send_request(peer_id, id, RPCRequest::Ping(ping));
@@ -576,7 +584,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         let ping = crate::rpc::Ping {
             data: self.network_globals.local_metadata.read().seq_number,
         };
-        trace!(self.log, "Sending Pong"; "request_id" => id.1, "peer_id" => peer_id.to_string());
+        trace!(self.log, "Sending Pong"; "request_id" => id.1, "peer_id" => %peer_id);
         let event = RPCCodedResponse::Success(RPCResponse::Pong(ping));
         self.eth2_rpc.send_response(peer_id, id, event);
     }
@@ -620,7 +628,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                             &propagation_source,
                             MessageAcceptance::Reject,
                         ) {
-                            warn!(self.log, "Failed to report message validation"; "message_id" => id.to_string(), "peer_id" => propagation_source.to_string(), "error" => format!("{:?}", e));
+                            warn!(self.log, "Failed to report message validation"; "message_id" => %id, "peer_id" => %propagation_source, "error" => ?e);
                         }
                     }
                     Ok(msg) => {
@@ -669,7 +677,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
             debug!(
                 self.log,
                 "Ignoring rpc message of disconnected peer";
-                "peer" => peer_id.to_string()
+                "peer" => %peer_id
             );
             return;
         }
@@ -730,9 +738,9 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                         // queue for disconnection without a goodbye message
                         debug!(
                             self.log, "Peer sent Goodbye";
-                            "peer_id" => peer_id.to_string(),
-                            "reason" => reason.to_string(),
-                            "client" => self.network_globals.client(&peer_id).to_string(),
+                            "peer_id" => %peer_id,
+                            "reason" => %reason,
+                            "client" => %self.network_globals.client(&peer_id),
                         );
                         self.peers_to_dc.push_back((peer_id, None));
                         // NOTE: We currently do not inform the application that we are
@@ -835,7 +843,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                     }
                     PeerManagerEvent::DisconnectPeer(peer_id, reason) => {
                         debug!(self.log, "PeerManager disconnecting peer";
-                            "peer_id" => peer_id.to_string(), "reason" => reason.to_string());
+                            "peer_id" => %peer_id, "reason" => %reason);
                         // send one goodbye
                         return Poll::Ready(NBAction::NotifyHandler {
                             peer_id,
@@ -881,12 +889,12 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
                 // send peer info to the peer manager.
                 self.peer_manager.identify(&peer_id, &info);
 
-                debug!(self.log, "Identified Peer"; "peer" => format!("{}", peer_id),
-                "protocol_version" => info.protocol_version,
-                "agent_version" => info.agent_version,
-                "listening_ addresses" => format!("{:?}", info.listen_addrs),
-                "observed_address" => format!("{:?}", observed_addr),
-                "protocols" => format!("{:?}", info.protocols)
+                debug!(self.log, "Identified Peer"; "peer" => %peer_id,
+                    "protocol_version" => info.protocol_version,
+                    "agent_version" => info.agent_version,
+                    "listening_ addresses" => ?info.listen_addrs,
+                    "observed_address" => ?observed_addr,
+                    "protocols" => ?info.protocols
                 );
             }
             IdentifyEvent::Sent { .. } => {}
@@ -985,10 +993,10 @@ impl<TSpec: EthSpec> NetworkBehaviour for Behaviour<TSpec> {
         if let Some(goodbye_reason) = goodbye_reason {
             match goodbye_reason {
                 GoodbyeReason::Banned => {
-                    debug!(self.log, "Disconnecting newly connected peer"; "peer_id" => peer_id.to_string(), "reason" => goodbye_reason.to_string())
+                    debug!(self.log, "Disconnecting newly connected peer"; "peer_id" => %peer_id, "reason" => %goodbye_reason)
                 }
                 _ => {
-                    trace!(self.log, "Disconnecting newly connected peer"; "peer_id" => peer_id.to_string(), "reason" => goodbye_reason.to_string())
+                    trace!(self.log, "Disconnecting newly connected peer"; "peer_id" => %peer_id, "reason" => %goodbye_reason)
                 }
             }
             self.peers_to_dc
@@ -1005,13 +1013,13 @@ impl<TSpec: EthSpec> NetworkBehaviour for Behaviour<TSpec> {
                 self.peer_manager
                     .connect_ingoing(&peer_id, send_back_addr.clone());
                 self.add_event(BehaviourEvent::PeerConnected(peer_id.clone()));
-                debug!(self.log, "Connection established"; "peer_id" => peer_id.to_string(), "connection" => "Incoming");
+                debug!(self.log, "Connection established"; "peer_id" => %peer_id, "connection" => "Incoming");
             }
             ConnectedPoint::Dialer { address } => {
                 self.peer_manager
                     .connect_outgoing(&peer_id, address.clone());
                 self.add_event(BehaviourEvent::PeerDialed(peer_id.clone()));
-                debug!(self.log, "Connection established"; "peer_id" => peer_id.to_string(), "connection" => "Dialed");
+                debug!(self.log, "Connection established"; "peer_id" => %peer_id, "connection" => "Dialed");
             }
         }
         // report the event to the behaviour
@@ -1310,8 +1318,8 @@ pub fn save_metadata_to_disk<E: EthSpec>(dir: &PathBuf, metadata: MetaData<E>, l
             warn!(
                 log,
                 "Could not write metadata to disk";
-                "file" => format!("{:?}{:?}",dir, METADATA_FILENAME),
-                "error" => format!("{}", e)
+                "file" => format!("{:?}{:?}", dir, METADATA_FILENAME),
+                "error" => %e
             );
         }
     }

beacon_node/eth2_libp2p/src/config.rs

@@ -88,6 +88,10 @@ pub struct Config {
     /// runtime.
     pub import_all_attestations: bool,
 
+    /// Indicates if the user has set the network to be in private mode. Currently this
+    /// prevents sending client identifying information over identify.
+    pub private: bool,
+
     /// List of extra topics to initially subscribe to as strings.
     pub topics: Vec<GossipKind>,
 }
@@ -188,6 +192,7 @@ impl Default for Config {
             client_version: lighthouse_version::version_with_platform(),
             disable_discovery: false,
             upnp_enabled: true,
+            private: false,
             subscribe_all_subnets: false,
             import_all_attestations: false,
             topics: Vec::new(),

beacon_node/eth2_libp2p/src/discovery/enr.rs

@@ -70,7 +70,7 @@ pub fn use_or_load_enr(
                         // if the same node id, then we may need to update our sequence number
                         if local_enr.node_id() == disk_enr.node_id() {
                             if compare_enr(&local_enr, &disk_enr) {
-                                debug!(log, "ENR loaded from disk"; "file" => format!("{:?}", enr_f));
+                                debug!(log, "ENR loaded from disk"; "file" => ?enr_f);
                                 // the stored ENR has the same configuration, use it
                                 *local_enr = disk_enr;
                                 return Ok(());
@@ -87,7 +87,7 @@ pub fn use_or_load_enr(
                         }
                     }
                     Err(e) => {
-                        warn!(log, "ENR from file could not be decoded"; "error" => format!("{:?}", e));
+                        warn!(log, "ENR from file could not be decoded"; "error" => ?e);
                     }
                 }
             }
@@ -188,7 +188,7 @@ pub fn save_enr_to_disk(dir: &Path, enr: &Enr, log: &slog::Logger) {
         Err(e) => {
             warn!(
                 log,
-                "Could not write ENR to file"; "file" => format!("{:?}{:?}",dir, ENR_FILENAME),  "error" => format!("{}", e)
+                "Could not write ENR to file"; "file" => format!("{:?}{:?}",dir, ENR_FILENAME),  "error" => %e
             );
         }
     }

beacon_node/eth2_libp2p/src/discovery/mod.rs

@@ -178,7 +178,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
 
         let local_enr = network_globals.local_enr.read().clone();
 
-        info!(log, "ENR Initialised"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> format!("{}",local_enr.node_id()), "ip" => format!("{:?}", local_enr.ip()), "udp"=> format!("{:?}", local_enr.udp()), "tcp" => format!("{:?}", local_enr.tcp()));
+        info!(log, "ENR Initialised"; "enr" => local_enr.to_base64(), "seq" => local_enr.seq(), "id"=> %local_enr.node_id(), "ip" => ?local_enr.ip(), "udp"=> ?local_enr.udp(), "tcp" => ?local_enr.tcp());
 
         let listen_socket = SocketAddr::new(config.listen_address, config.discovery_port);
 
@@ -193,11 +193,11 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
             debug!(
                 log,
                 "Adding node to routing table";
-                "node_id" => bootnode_enr.node_id().to_string(),
-                "peer_id" => bootnode_enr.peer_id().to_string(),
-                "ip" => format!("{:?}", bootnode_enr.ip()),
-                "udp" => format!("{:?}", bootnode_enr.udp()),
-                "tcp" => format!("{:?}", bootnode_enr.tcp())
+                "node_id" => %bootnode_enr.node_id(),
+                "peer_id" => %bootnode_enr.peer_id(),
+                "ip" => ?bootnode_enr.ip(),
+                "udp" => ?bootnode_enr.udp(),
+                "tcp" => ?bootnode_enr.tcp()
             );
             let repr = bootnode_enr.to_string();
             let _ = discv5.add_enr(bootnode_enr).map_err(|e| {
@@ -247,11 +247,11 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                     debug!(
                         log,
                         "Adding node to routing table";
-                        "node_id" => enr.node_id().to_string(),
-                        "peer_id" => enr.peer_id().to_string(),
-                        "ip" => format!("{:?}", enr.ip()),
-                        "udp" => format!("{:?}", enr.udp()),
-                        "tcp" => format!("{:?}", enr.tcp())
+                        "node_id" => %enr.node_id(),
+                        "peer_id" => %enr.peer_id(),
+                        "ip" => ?enr.ip(),
+                        "udp" => ?enr.udp(),
+                        "tcp" => ?enr.tcp()
                     );
                     let _ = discv5.add_enr(enr).map_err(|e| {
                         error!(
@@ -318,7 +318,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
         debug!(
             self.log,
             "Making discovery query for subnets";
-            "subnets" => format!("{:?}", subnets_to_discover.iter().map(|s| s.subnet_id).collect::<Vec<_>>())
+            "subnets" => ?subnets_to_discover.iter().map(|s| s.subnet_id).collect::<Vec<_>>()
         );
         for subnet in subnets_to_discover {
             self.add_subnet_query(subnet.subnet_id, subnet.min_ttl, 0);
@@ -334,7 +334,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
             debug!(
                 self.log,
                 "Could not add peer to the local routing table";
-                "error" => e.to_string()
+                "error" => %e
             )
         }
     }
@@ -461,8 +461,8 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
         };
 
         info!(self.log, "Updating the ENR fork version";
-            "fork_digest" => format!("{:?}", enr_fork_id.fork_digest),
-            "next_fork_version" => format!("{:?}", enr_fork_id.next_fork_version),
+            "fork_digest" => ?enr_fork_id.fork_digest,
+            "next_fork_version" => ?enr_fork_id.next_fork_version,
             "next_fork_epoch" => next_fork_epoch_log,
         );
 
@@ -473,7 +473,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                 warn!(
                     self.log,
                     "Could not update eth2 ENR field";
-                    "error" => format!("{:?}", e)
+                    "error" => ?e
                 )
             });
 
@@ -607,7 +607,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                         debug!(
                             self.log,
                             "Starting grouped subnet query";
-                            "subnets" => format!("{:?}", grouped_queries.iter().map(|q| q.subnet_id).collect::<Vec<_>>()),
+                            "subnets" => ?grouped_queries.iter().map(|q| q.subnet_id).collect::<Vec<_>>(),
                         );
                         self.start_subnet_query(grouped_queries);
                         processed = true;
@@ -659,7 +659,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                     "target_subnet_peers" => TARGET_SUBNET_PEERS,
                     "peers_to_find" => target_peers,
                     "attempt" => subnet_query.retries,
-                    "min_ttl" => format!("{:?}", subnet_query.min_ttl),
+                    "min_ttl" => ?subnet_query.min_ttl,
                 );
 
                 filtered_subnet_ids.push(subnet_query.subnet_id);
@@ -757,7 +757,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                         return Some(results);
                     }
                     Err(e) => {
-                        warn!(self.log, "Discovery query failed"; "error" => e.to_string());
+                        warn!(self.log, "Discovery query failed"; "error" => %e);
                     }
                 }
             }
@@ -766,10 +766,10 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                     queries.iter().map(|query| query.subnet_id).collect();
                 match query_result.1 {
                     Ok(r) if r.is_empty() => {
-                        debug!(self.log, "Grouped subnet discovery query yielded no results."; "subnets_searched_for" => format!("{:?}",subnets_searched_for));
+                        debug!(self.log, "Grouped subnet discovery query yielded no results."; "subnets_searched_for" => ?subnets_searched_for);
                     }
                     Ok(r) => {
-                        debug!(self.log, "Peer grouped subnet discovery request completed"; "peers_found" => r.len(), "subnets_searched_for" => format!("{:?}",subnets_searched_for));
+                        debug!(self.log, "Peer grouped subnet discovery request completed"; "peers_found" => r.len(), "subnets_searched_for" => ?subnets_searched_for);
 
                         let mut mapped_results = HashMap::new();
 
@@ -836,7 +836,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                         }
                     }
                     Err(e) => {
-                        warn!(self.log,"Grouped subnet discovery query failed"; "subnets_searched_for" => format!("{:?}",subnets_searched_for), "error" => e.to_string());
+                        warn!(self.log,"Grouped subnet discovery query failed"; "subnets_searched_for" => ?subnets_searched_for, "error" => %e);
                     }
                 }
             }
@@ -881,7 +881,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                             self.event_stream = EventStream::Present(stream);
                         }
                         Err(e) => {
-                            slog::crit!(self.log, "Discv5 event stream failed"; "error" => e.to_string());
+                            slog::crit!(self.log, "Discv5 event stream failed"; "error" => %e);
                             self.event_stream = EventStream::InActive;
                         }
                     }
@@ -907,7 +907,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
                             */
                         }
                         Discv5Event::SocketUpdated(socket) => {
-                            info!(self.log, "Address updated"; "ip" => format!("{}",socket.ip()), "udp_port" => format!("{}", socket.port()));
+                            info!(self.log, "Address updated"; "ip" => %socket.ip(), "udp_port" => %socket.port());
                             metrics::inc_counter(&metrics::ADDRESS_UPDATE_COUNT);
                             // Discv5 will have updated our local ENR. We save the updated version
                             // to disk.

beacon_node/eth2_libp2p/src/discovery/subnet_predicate.rs

@@ -34,15 +34,15 @@ where
                 trace!(
                     log_clone,
                     "Peer found but not on any of the desired subnets";
-                    "peer_id" => format!("{}", enr.peer_id())
+                    "peer_id" => %enr.peer_id()
                 );
                 return false;
             } else {
                 trace!(
                    log_clone,
                    "Peer found on desired subnet(s)";
-                   "peer_id" => format!("{}", enr.peer_id()),
-                   "subnets" => format!("{:?}", matches.as_slice())
+                   "peer_id" => %enr.peer_id(),
+                   "subnets" => ?matches.as_slice()
                 );
                 return true;
             }

beacon_node/eth2_libp2p/src/peer_manager/mod.rs

@@ -11,7 +11,7 @@ use futures::Stream;
 use hashset_delay::HashSetDelay;
 use libp2p::core::multiaddr::Protocol as MProtocol;
 use libp2p::identify::IdentifyInfo;
-use slog::{crit, debug, error, warn};
+use slog::{crit, debug, error, trace, warn};
 use smallvec::SmallVec;
 use std::{
     net::SocketAddr,
@@ -193,7 +193,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
                     &self.log,
                 );
                 if previous_state == info.score_state() {
-                    debug!(self.log, "Peer score adjusted"; "peer_id" => peer_id.to_string(), "score" => info.score().to_string());
+                    debug!(self.log, "Peer score adjusted"; "peer_id" => %peer_id, "score" => %info.score());
                 }
             }
         } // end write lock
@@ -238,10 +238,10 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
                     .good_peers_on_subnet(s.subnet_id)
                     .count();
                 if peers_on_subnet >= TARGET_SUBNET_PEERS {
-                    debug!(
+                    trace!(
                         self.log,
                         "Discovery query ignored";
-                        "subnet_id" => format!("{:?}",s.subnet_id),
+                        "subnet_id" => ?s.subnet_id,
                         "reason" => "Already connected to desired peers",
                         "connected_peers_on_subnet" => peers_on_subnet,
                         "target_subnet_peers" => TARGET_SUBNET_PEERS,
@@ -441,7 +441,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
         if let Some(peer_info) = self.network_globals.peers.read().peer_info(peer_id) {
             // received a ping
             // reset the to-ping timer for this peer
-            debug!(self.log, "Received a ping request"; "peer_id" => peer_id.to_string(), "seq_no" => seq);
+            debug!(self.log, "Received a ping request"; "peer_id" => %peer_id, "seq_no" => seq);
             match peer_info.connection_direction {
                 Some(ConnectionDirection::Incoming) => {
                     self.inbound_ping_peers.insert(peer_id.clone());
@@ -458,20 +458,20 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             if let Some(meta_data) = &peer_info.meta_data {
                 if meta_data.seq_number < seq {
                     debug!(self.log, "Requesting new metadata from peer";
-                        "peer_id" => peer_id.to_string(), "known_seq_no" => meta_data.seq_number, "ping_seq_no" => seq);
+                        "peer_id" => %peer_id, "known_seq_no" => meta_data.seq_number, "ping_seq_no" => seq);
                     self.events
                         .push(PeerManagerEvent::MetaData(peer_id.clone()));
                 }
             } else {
                 // if we don't know the meta-data, request it
                 debug!(self.log, "Requesting first metadata from peer";
-                    "peer_id" => peer_id.to_string());
+                    "peer_id" => %peer_id);
                 self.events
                     .push(PeerManagerEvent::MetaData(peer_id.clone()));
             }
         } else {
             crit!(self.log, "Received a PING from an unknown peer";
-                "peer_id" => peer_id.to_string());
+                "peer_id" => %peer_id);
         }
     }
 
@@ -484,19 +484,19 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             if let Some(meta_data) = &peer_info.meta_data {
                 if meta_data.seq_number < seq {
                     debug!(self.log, "Requesting new metadata from peer";
-                        "peer_id" => peer_id.to_string(), "known_seq_no" => meta_data.seq_number, "pong_seq_no" => seq);
+                        "peer_id" => %peer_id, "known_seq_no" => meta_data.seq_number, "pong_seq_no" => seq);
                     self.events
                         .push(PeerManagerEvent::MetaData(peer_id.clone()));
                 }
             } else {
                 // if we don't know the meta-data, request it
                 debug!(self.log, "Requesting first metadata from peer";
-                    "peer_id" => peer_id.to_string());
+                    "peer_id" => %peer_id);
                 self.events
                     .push(PeerManagerEvent::MetaData(peer_id.clone()));
             }
         } else {
-            crit!(self.log, "Received a PONG from an unknown peer"; "peer_id" => peer_id.to_string());
+            crit!(self.log, "Received a PONG from an unknown peer"; "peer_id" => %peer_id);
         }
     }
 
@@ -506,21 +506,21 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             if let Some(known_meta_data) = &peer_info.meta_data {
                 if known_meta_data.seq_number < meta_data.seq_number {
                     debug!(self.log, "Updating peer's metadata";
-                        "peer_id" => peer_id.to_string(), "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
+                        "peer_id" => %peer_id, "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
                     peer_info.meta_data = Some(meta_data);
                 } else {
                     debug!(self.log, "Received old metadata";
-                        "peer_id" => peer_id.to_string(), "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
+                        "peer_id" => %peer_id, "known_seq_no" => known_meta_data.seq_number, "new_seq_no" => meta_data.seq_number);
                 }
             } else {
                 // we have no meta-data for this peer, update
                 debug!(self.log, "Obtained peer's metadata";
-                    "peer_id" => peer_id.to_string(), "new_seq_no" => meta_data.seq_number);
+                    "peer_id" => %peer_id, "new_seq_no" => meta_data.seq_number);
                 peer_info.meta_data = Some(meta_data);
             }
         } else {
             crit!(self.log, "Received METADATA from an unknown peer";
-                "peer_id" => peer_id.to_string());
+                "peer_id" => %peer_id);
         }
     }
 
@@ -672,7 +672,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             }
         }
         for peer_id in to_dial_peers {
-            debug!(self.log, "Dialing discovered peer"; "peer_id"=> peer_id.to_string());
+            debug!(self.log, "Dialing discovered peer"; "peer_id" => %peer_id);
             self.dial_peer(&peer_id);
         }
     }
@@ -688,7 +688,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             let mut peerdb = self.network_globals.peers.write();
             if peerdb.is_banned(&peer_id) {
                 // don't connect if the peer is banned
-                slog::crit!(self.log, "Connection has been allowed to a banned peer"; "peer_id" => peer_id.to_string());
+                slog::crit!(self.log, "Connection has been allowed to a banned peer"; "peer_id" => %peer_id);
             }
 
             let enr = self.discovery.enr_of_peer(peer_id);
@@ -751,11 +751,11 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
         if previous_state != info.score_state() {
             match info.score_state() {
                 ScoreState::Banned => {
-                    debug!(log, "Peer has been banned"; "peer_id" => peer_id.to_string(), "score" => info.score().to_string());
+                    debug!(log, "Peer has been banned"; "peer_id" => %peer_id, "score" => %info.score());
                     to_ban_peers.push(peer_id.clone());
                 }
                 ScoreState::Disconnected => {
-                    debug!(log, "Peer transitioned to disconnect state"; "peer_id" => peer_id.to_string(), "score" => info.score().to_string(), "past_state" => previous_state.to_string());
+                    debug!(log, "Peer transitioned to disconnect state"; "peer_id" => %peer_id, "score" => %info.score(), "past_state" => %previous_state);
                     // disconnect the peer if it's currently connected or dialing
                     if info.is_connected_or_dialing() {
                         // Change the state to inform that we are disconnecting the peer.
@@ -769,7 +769,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
                     }
                 }
                 ScoreState::Healthy => {
-                    debug!(log, "Peer transitioned to healthy state"; "peer_id" => peer_id.to_string(), "score" => info.score().to_string(), "past_state" => previous_state.to_string());
+                    debug!(log, "Peer transitioned to healthy state"; "peer_id" => %peer_id, "score" => %info.score(), "past_state" => %previous_state);
                     // unban the peer if it was previously banned.
                     if info.is_banned() {
                         to_unban_peers.push(peer_id.clone());

beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs

@@ -347,7 +347,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
                 .checked_duration_since(Instant::now())
                 .map(|duration| duration.as_secs())
                 .unwrap_or_else(|| 0);
-            debug!(self.log, "Updating the time a peer is required for"; "peer_id" => peer_id.to_string(), "future_min_ttl_secs" => min_ttl_secs);
+            debug!(self.log, "Updating the time a peer is required for"; "peer_id" => %peer_id, "future_min_ttl_secs" => min_ttl_secs);
         }
     }
 
@@ -457,7 +457,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
         let log_ref = &self.log;
         let info = self.peers.entry(peer_id.clone()).or_insert_with(|| {
             warn!(log_ref, "Banning unknown peer";
-                "peer_id" => peer_id.to_string());
+                "peer_id" => %peer_id);
             PeerInfo::default()
         });
 
@@ -514,7 +514,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
         let log_ref = &self.log;
         let info = self.peers.entry(peer_id.clone()).or_insert_with(|| {
             warn!(log_ref, "UnBanning unknown peer";
-                "peer_id" => peer_id.to_string());
+                "peer_id" => %peer_id);
             PeerInfo::default()
         });
 
@@ -563,7 +563,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
                 self.banned_peers_count = BannedPeersCount::new();
                 None
             } {
-                debug!(self.log, "Removing old banned peer"; "peer_id" => to_drop.to_string());
+                debug!(self.log, "Removing old banned peer"; "peer_id" => %to_drop);
                 self.peers.remove(&to_drop);
             }
         }
@@ -581,7 +581,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
                 .min_by_key(|(_, since)| *since)
                 .map(|(id, _)| id.clone())
             {
-                debug!(self.log, "Removing old disconnected peer"; "peer_id" => to_drop.to_string());
+                debug!(self.log, "Removing old disconnected peer"; "peer_id" => %to_drop);
                 self.peers.remove(&to_drop);
             }
             // If there is no minimum, this is a coding error. For safety we decrease
@@ -595,7 +595,7 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
         if let Some(peer_info) = self.peers.get_mut(peer_id) {
             peer_info.meta_data = Some(meta_data);
         } else {
-            warn!(self.log, "Tried to add meta data for a non-existant peer"; "peer_id" => peer_id.to_string());
+            warn!(self.log, "Tried to add meta data for a non-existent peer"; "peer_id" => %peer_id);
         }
     }
 }

beacon_node/eth2_libp2p/src/rpc/handler.rs

@@ -307,7 +307,7 @@ where
         if matches!(self.state, HandlerState::Deactivated) {
             // we no longer send responses after the handler is deactivated
             debug!(self.log, "Response not sent. Deactivated handler";
-                "response" => response.to_string(), "id" => inbound_id);
+                "response" => %response, "id" => inbound_id);
             return;
         }
         inbound_info.pending_items.push(response);
@@ -419,7 +419,7 @@ where
                 )
                 .is_some()
             {
-                crit!(self.log, "Duplicate outbound substream id"; "id" => format!("{:?}", self.current_outbound_substream_id));
+                crit!(self.log, "Duplicate outbound substream id"; "id" => self.current_outbound_substream_id);
             }
             self.current_outbound_substream_id.0 += 1;
         }
@@ -563,7 +563,7 @@ where
                     }
                 }
                 Poll::Ready(Some(Err(e))) => {
-                    warn!(self.log, "Inbound substream poll failed"; "error" => format!("{:?}", e));
+                    warn!(self.log, "Inbound substream poll failed"; "error" => ?e);
                     // drops the peer if we cannot read the delay queue
                     return Poll::Ready(ProtocolsHandlerEvent::Close(RPCError::InternalError(
                         "Could not poll inbound stream timer",
@@ -592,7 +592,7 @@ where
                     }
                 }
                 Poll::Ready(Some(Err(e))) => {
-                    warn!(self.log, "Outbound substream poll failed"; "error" => format!("{:?}", e));
+                    warn!(self.log, "Outbound substream poll failed"; "error" => ?e);
                     return Poll::Ready(ProtocolsHandlerEvent::Close(RPCError::InternalError(
                         "Could not poll outbound stream timer",
                     )));

beacon_node/eth2_libp2p/src/rpc/methods.rs

@@ -399,11 +399,11 @@ impl slog::KV for StatusMessage {
         serializer: &mut dyn slog::Serializer,
     ) -> slog::Result {
         use slog::Value;
-        serializer.emit_str("fork_digest", &format!("{:?}", self.fork_digest))?;
+        serializer.emit_arguments("fork_digest", &format_args!("{:?}", self.fork_digest))?;
         Value::serialize(&self.finalized_epoch, record, "finalized_epoch", serializer)?;
-        serializer.emit_str("finalized_root", &self.finalized_root.to_string())?;
+        serializer.emit_arguments("finalized_root", &format_args!("{}", self.finalized_root))?;
         Value::serialize(&self.head_slot, record, "head_slot", serializer)?;
-        serializer.emit_str("head_root", &self.head_root.to_string())?;
+        serializer.emit_arguments("head_root", &format_args!("{}", self.head_root))?;
         slog::Result::Ok(())
     }
 }

beacon_node/eth2_libp2p/src/rpc/mod.rs

@@ -187,7 +187,7 @@ where
     // Use connection established/closed instead of these currently
     fn inject_connected(&mut self, peer_id: &PeerId) {
         // find the peer's meta-data
-        debug!(self.log, "Requesting new peer's metadata"; "peer_id" => format!("{}",peer_id));
+        debug!(self.log, "Requesting new peer's metadata"; "peer_id" => %peer_id);
         let rpc_event = RPCSend::Request(RequestId::Behaviour, RPCRequest::MetaData(PhantomData));
         self.events.push(NetworkBehaviourAction::NotifyHandler {
             peer_id: peer_id.clone(),
@@ -253,7 +253,7 @@ where
                 }
                 Err(RateLimitedErr::TooSoon(wait_time)) => {
                     debug!(self.log, "Request exceeds the rate limit";
-                        "request" => req.to_string(), "peer_id" => peer_id.to_string(), "wait_time_ms" => wait_time.as_millis());
+                        "request" => %req, "peer_id" => %peer_id, "wait_time_ms" => wait_time.as_millis());
                     // send an error code to the peer.
                     // the handler upon receiving the error code will send it back to the behaviour
                     self.send_response(

beacon_node/eth2_libp2p/src/service.rs

@@ -93,13 +93,13 @@ impl<TSpec: EthSpec> Service<TSpec> {
             &log,
         ));
 
-        info!(log, "Libp2p Service"; "peer_id" => enr.peer_id().to_string());
+        info!(log, "Libp2p Service"; "peer_id" => %enr.peer_id());
         let discovery_string = if config.disable_discovery {
             "None".into()
         } else {
             config.discovery_port.to_string()
         };
-        debug!(log, "Attempting to open listening ports"; "address" => format!("{}", config.listen_address), "tcp_port" => config.libp2p_port, "udp_port" => discovery_string);
+        debug!(log, "Attempting to open listening ports"; "address" => ?config.listen_address, "tcp_port" => config.libp2p_port, "udp_port" => discovery_string);
 
         let (mut swarm, bandwidth) = {
             // Set up the transport - tcp/ws with noise and mplex
@@ -147,14 +147,14 @@ impl<TSpec: EthSpec> Service<TSpec> {
             Ok(_) => {
                 let mut log_address = listen_multiaddr;
                 log_address.push(Protocol::P2p(local_peer_id.clone().into()));
-                info!(log, "Listening established"; "address" => format!("{}", log_address));
+                info!(log, "Listening established"; "address" => %log_address);
             }
             Err(err) => {
                 crit!(
                     log,
                     "Unable to listen on libp2p address";
-                    "error" => format!("{:?}", err),
-                    "listen_multiaddr" => format!("{}", listen_multiaddr),
+                    "error" => ?err,
+                    "listen_multiaddr" => %listen_multiaddr,
                 );
                 return Err("Libp2p was unable to listen on the given listen address.".into());
             }
@@ -165,10 +165,10 @@ impl<TSpec: EthSpec> Service<TSpec> {
             // strip the p2p protocol if it exists
             strip_peer_id(&mut multiaddr);
             match Swarm::dial_addr(&mut swarm, multiaddr.clone()) {
-                Ok(()) => debug!(log, "Dialing libp2p peer"; "address" => format!("{}", multiaddr)),
+                Ok(()) => debug!(log, "Dialing libp2p peer"; "address" => %multiaddr),
                 Err(err) => debug!(
                     log,
-                    "Could not connect to peer"; "address" => format!("{}", multiaddr), "error" => format!("{:?}", err)
+                    "Could not connect to peer"; "address" => %multiaddr, "error" => ?err
                 ),
             };
         };
@@ -216,12 +216,12 @@ impl<TSpec: EthSpec> Service<TSpec> {
             if swarm.subscribe_kind(topic_kind.clone()) {
                 subscribed_topics.push(topic_kind.clone());
             } else {
-                warn!(log, "Could not subscribe to topic"; "topic" => format!("{}",topic_kind));
+                warn!(log, "Could not subscribe to topic"; "topic" => %topic_kind);
             }
         }
 
         if !subscribed_topics.is_empty() {
-            info!(log, "Subscribed to topics"; "topics" => format!("{:?}", subscribed_topics));
+            info!(log, "Subscribed to topics"; "topics" => ?subscribed_topics);
         }
 
         let service = Service {
@@ -279,7 +279,7 @@ impl<TSpec: EthSpec> Service<TSpec> {
                     endpoint: _,
                     num_established,
                 } => {
-                    trace!(self.log, "Connection closed"; "peer_id"=> peer_id.to_string(), "cause" => format!("{:?}", cause), "connections" => num_established);
+                    trace!(self.log, "Connection closed"; "peer_id" => %peer_id, "cause" => ?cause, "connections" => num_established);
                 }
                 SwarmEvent::NewListenAddr(multiaddr) => {
                     return Libp2pEvent::NewListenAddr(multiaddr)
@@ -288,14 +288,14 @@ impl<TSpec: EthSpec> Service<TSpec> {
                     local_addr,
                     send_back_addr,
                 } => {
-                    trace!(self.log, "Incoming connection"; "our_addr" => local_addr.to_string(), "from" => send_back_addr.to_string())
+                    trace!(self.log, "Incoming connection"; "our_addr" => %local_addr, "from" => %send_back_addr)
                 }
                 SwarmEvent::IncomingConnectionError {
                     local_addr,
                     send_back_addr,
                     error,
                 } => {
-                    debug!(self.log, "Failed incoming connection"; "our_addr" => local_addr.to_string(), "from" => send_back_addr.to_string(), "error" => error.to_string())
+                    debug!(self.log, "Failed incoming connection"; "our_addr" => %local_addr, "from" => %send_back_addr, "error" => %error)
                 }
                 SwarmEvent::BannedPeer { .. } => {
                     // We do not ban peers at the swarm layer, so this should never occur.
@@ -306,29 +306,29 @@ impl<TSpec: EthSpec> Service<TSpec> {
                     error,
                     attempts_remaining,
                 } => {
-                    debug!(self.log, "Failed to dial address"; "peer_id" => peer_id.to_string(), "address" => address.to_string(), "error" => error.to_string(), "attempts_remaining" => attempts_remaining);
+                    debug!(self.log, "Failed to dial address"; "peer_id" => %peer_id, "address" => %address, "error" => %error, "attempts_remaining" => attempts_remaining);
                 }
                 SwarmEvent::UnknownPeerUnreachableAddr { address, error } => {
-                    debug!(self.log, "Peer not known at dialed address"; "address" => address.to_string(), "error" => error.to_string());
+                    debug!(self.log, "Peer not known at dialed address"; "address" => %address, "error" => %error);
                 }
                 SwarmEvent::ExpiredListenAddr(multiaddr) => {
-                    debug!(self.log, "Listen address expired"; "multiaddr" => multiaddr.to_string())
+                    debug!(self.log, "Listen address expired"; "multiaddr" => %multiaddr)
                 }
                 SwarmEvent::ListenerClosed { addresses, reason } => {
-                    crit!(self.log, "Listener closed"; "addresses" => format!("{:?}", addresses), "reason" => format!("{:?}", reason));
+                    crit!(self.log, "Listener closed"; "addresses" => ?addresses, "reason" => ?reason);
                     if Swarm::listeners(&self.swarm).count() == 0 {
                         return Libp2pEvent::ZeroListeners;
                     }
                 }
                 SwarmEvent::ListenerError { error } => {
                     // this is non fatal, but we still check
-                    warn!(self.log, "Listener error"; "error" => format!("{:?}", error.to_string()));
+                    warn!(self.log, "Listener error"; "error" => ?error);
                     if Swarm::listeners(&self.swarm).count() == 0 {
                         return Libp2pEvent::ZeroListeners;
                     }
                 }
                 SwarmEvent::Dialing(peer_id) => {
-                    debug!(self.log, "Dialing peer"; "peer_id" => peer_id.to_string());
+                    debug!(self.log, "Dialing peer"; "peer_id" => %peer_id);
                 }
             }
         }
@@ -492,7 +492,7 @@ fn load_or_build_metadata<E: EthSpec>(
                     debug!(
                         log,
                         "Metadata from file could not be decoded";
-                        "error" => format!("{:?}", e),
+                        "error" => ?e,
                     );
                 }
             }

beacon_node/http_api/src/lib.rs

@@ -2075,9 +2075,7 @@ pub fn serve<T: BeaconChainTypes>(
                 let head_info = chain
                     .head_info()
                     .map_err(warp_utils::reject::beacon_chain_error)?;
-                let current_slot = chain
-                    .slot()
-                    .map_err(warp_utils::reject::beacon_chain_error)?;
+                let current_slot_opt = chain.slot().ok();
 
                 chain
                     .eth1_chain
@@ -2088,7 +2086,7 @@ pub fn serve<T: BeaconChainTypes>(
                         )
                     })
                     .and_then(|eth1| {
-                        eth1.sync_status(head_info.genesis_time, current_slot, &chain.spec)
+                        eth1.sync_status(head_info.genesis_time, current_slot_opt, &chain.spec)
                             .ok_or_else(|| {
                                 warp_utils::reject::custom_server_error(
                                     "Unable to determine Eth1 sync status".to_string(),

beacon_node/network/src/attestation_service/mod.rs

@@ -206,7 +206,7 @@ impl<T: BeaconChainTypes> AttestationService<T> {
             // This will subscribe to long-lived random subnets if required.
             trace!(self.log,
                 "Validator subscription";
-                "subscription" => format!("{:?}", subscription),
+                "subscription" => ?subscription,
             );
             self.add_known_validator(subscription.validator_index);
 
@@ -220,7 +220,7 @@ impl<T: BeaconChainTypes> AttestationService<T> {
                 Err(e) => {
                     warn!(self.log,
                         "Failed to compute subnet id for validator subscription";
-                        "error" => format!("{:?}", e),
+                        "error" => ?e,
                         "validator_index" => subscription.validator_index
                     );
                     continue;
@@ -257,7 +257,7 @@ impl<T: BeaconChainTypes> AttestationService<T> {
                 } else {
                     trace!(self.log,
                         "Subscribed to subnet for aggregator duties";
-                        "exact_subnet" => format!("{:?}", exact_subnet),
+                        "exact_subnet" => ?exact_subnet,
                         "validator_index" => subscription.validator_index
                     );
                 }
@@ -339,7 +339,7 @@ impl<T: BeaconChainTypes> AttestationService<T> {
                     // peer before they can be removed.
                     warn!(self.log,
                         "Not enough time for a discovery search";
-                        "subnet_id" => format!("{:?}", exact_subnet)
+                        "subnet_id" => ?exact_subnet
                     );
                     None
                 }

beacon_node/network/src/beacon_processor/mod.rs

@@ -961,7 +961,7 @@ impl Drop for SendOnDrop {
                 self.log,
                 "Unable to free worker";
                 "msg" => "did not free worker, shutdown may be underway",
-                "error" => e.to_string()
+                "error" => %e
             )
         }
     }

beacon_node/network/src/beacon_processor/worker/gossip_methods.rs

@@ -212,7 +212,7 @@ impl<T: BeaconChainTypes> Worker<T> {
                     self.log,
                     "New block received";
                     "slot" => verified_block.block.slot(),
-                    "hash" => verified_block.block_root.to_string()
+                    "hash" => %verified_block.block_root
                 );
                 self.propagate_validation_result(
                     message_id,
@@ -232,7 +232,7 @@ impl<T: BeaconChainTypes> Worker<T> {
             | Err(e @ BlockError::NotFinalizedDescendant { .. })
             | Err(e @ BlockError::BeaconChainError(_)) => {
                 debug!(self.log, "Could not verify block for gossip, ignoring the block";
-                            "error" => e.to_string());
+                            "error" => %e);
                 // Prevent recurring behaviour by penalizing the peer slightly.
                 self.penalize_peer(peer_id.clone(), PeerAction::HighToleranceError);
                 self.propagate_validation_result(message_id, peer_id, MessageAcceptance::Ignore);
@@ -252,7 +252,7 @@ impl<T: BeaconChainTypes> Worker<T> {
             | Err(e @ BlockError::WeakSubjectivityConflict)
             | Err(e @ BlockError::GenesisBlock) => {
                 warn!(self.log, "Could not verify block for gossip, rejecting the block";
-                            "error" => e.to_string());
+                            "error" => %e);
                 self.propagate_validation_result(
                     message_id,
                     peer_id.clone(),
@@ -307,15 +307,15 @@ impl<T: BeaconChainTypes> Worker<T> {
                 debug!(
                     self.log,
                     "Invalid gossip beacon block";
-                    "outcome" => format!("{:?}", other),
-                    "block root" => format!("{}", block.canonical_root()),
+                    "outcome" => ?other,
+                    "block root" => %block.canonical_root(),
                     "block slot" => block.slot()
                 );
                 self.penalize_peer(peer_id, PeerAction::MidToleranceError);
                 trace!(
                     self.log,
                     "Invalid gossip beacon block ssz";
-                    "ssz" => format!("0x{}", hex::encode(block.as_ssz_bytes())),
+                    "ssz" => format_args!("0x{}", hex::encode(block.as_ssz_bytes())),
                 );
             }
         };
@@ -787,8 +787,8 @@ impl<T: BeaconChainTypes> Worker<T> {
                 debug!(
                     self.log,
                     "Received attestation on incorrect subnet";
-                    "expected" => format!("{:?}", expected),
-                    "received" => format!("{:?}", received),
+                    "expected" => ?expected,
+                    "received" => ?received,
                 );
                 self.propagate_validation_result(
                     message_id,

beacon_node/network/src/router/mod.rs

@@ -225,14 +225,14 @@ impl<T: BeaconChainTypes> Router<T> {
                 self.processor.on_block_gossip(id, peer_id, block);
             }
             PubsubMessage::VoluntaryExit(exit) => {
-                debug!(self.log, "Received a voluntary exit"; "peer_id" => format!("{}", peer_id));
+                debug!(self.log, "Received a voluntary exit"; "peer_id" => %peer_id);
                 self.processor.on_voluntary_exit_gossip(id, peer_id, exit);
             }
             PubsubMessage::ProposerSlashing(proposer_slashing) => {
                 debug!(
                     self.log,
                     "Received a proposer slashing";
-                    "peer_id" => format!("{}", peer_id)
+                    "peer_id" => %peer_id
                 );
                 self.processor
                     .on_proposer_slashing_gossip(id, peer_id, proposer_slashing);
@@ -241,7 +241,7 @@ impl<T: BeaconChainTypes> Router<T> {
                 debug!(
                     self.log,
                     "Received a attester slashing";
-                    "peer_id" => format!("{}", peer_id)
+                    "peer_id" => %peer_id
                 );
                 self.processor
                     .on_attester_slashing_gossip(id, peer_id, attester_slashing);

beacon_node/network/src/router/processor.rs

@@ -179,7 +179,7 @@ impl<T: BeaconChainTypes> Processor<T> {
         trace!(
             self.log,
             "Received BlocksByRange Response";
-            "peer" => peer_id.to_string(),
+            "peer" => %peer_id,
         );
 
         if let RequestId::Sync(id) = request_id {
@@ -206,7 +206,7 @@ impl<T: BeaconChainTypes> Processor<T> {
         trace!(
             self.log,
             "Received BlocksByRoot Response";
-            "peer" => peer_id.to_string(),
+            "peer" => %peer_id,
         );
 
         if let RequestId::Sync(id) = request_id {
@@ -356,10 +356,9 @@ impl<T: EthSpec> HandlerNetworkContext<T> {
 
     /// Sends a message to the network task.
     fn inform_network(&mut self, msg: NetworkMessage<T>) {
-        let msg_r = &format!("{:?}", msg);
-        self.network_send
-            .send(msg)
-            .unwrap_or_else(|e| warn!(self.log, "Could not send message to the network service"; "error" => %e, "message" => msg_r))
+        self.network_send.send(msg).unwrap_or_else(
+            |e| warn!(self.log, "Could not send message to the network service"; "error" => %e),
+        )
     }
 
     /// Disconnects and ban's a peer, sending a Goodbye request with the associated reason.

beacon_node/network/src/service.rs

@@ -241,13 +241,13 @@ fn spawn_service<T: BeaconChainTypes>(
                     debug!(
                         service.log,
                         "Persisting DHT to store";
-                        "Number of peers" => format!("{}", enrs.len()),
+                        "Number of peers" => enrs.len(),
                     );
                     match persist_dht::<T::EthSpec, T::HotStore, T::ColdStore>(service.store.clone(), enrs) {
                         Err(e) => error!(
                             service.log,
                             "Failed to persist DHT on drop";
-                            "error" => format!("{:?}", e)
+                            "error" => ?e
                         ),
                         Ok(_) => info!(
                             service.log,
@@ -354,9 +354,9 @@ fn spawn_service<T: BeaconChainTypes>(
                             validation_result,
                         } => {
                                 trace!(service.log, "Propagating gossipsub message";
-                                    "propagation_peer" => format!("{:?}", propagation_source),
-                                    "message_id" => message_id.to_string(),
-                                    "validation_result" => format!("{:?}", validation_result)
+                                    "propagation_peer" => ?propagation_source,
+                                    "message_id" => %message_id,
+                                    "validation_result" => ?validation_result
                                 );
                                 service
                                     .libp2p
@@ -376,7 +376,7 @@ fn spawn_service<T: BeaconChainTypes>(
                                     service.log,
                                     "Sending pubsub messages";
                                     "count" => messages.len(),
-                                    "topics" => format!("{:?}", topic_kinds)
+                                    "topics" => ?topic_kinds
                                 );
                                 metrics::expose_publish_metrics(&messages);
                                 service.libp2p.swarm.publish(messages);
@@ -398,7 +398,7 @@ fn spawn_service<T: BeaconChainTypes>(
                                 if service.libp2p.swarm.subscribe_kind(topic_kind.clone()) {
                                     subscribed_topics.push(topic_kind.clone());
                                 } else {
-                                    warn!(service.log, "Could not subscribe to topic"; "topic" => format!("{}",topic_kind));
+                                    warn!(service.log, "Could not subscribe to topic"; "topic" => %topic_kind);
                                 }
                             }
 
@@ -412,13 +412,13 @@ fn spawn_service<T: BeaconChainTypes>(
                                     service.libp2p.swarm.update_enr_subnet(subnet_id, true);
                                     subscribed_topics.push(topic_kind.clone());
                                 } else {
-                                    warn!(service.log, "Could not subscribe to topic"; "topic" => format!("{}",topic_kind));
+                                    warn!(service.log, "Could not subscribe to topic"; "topic" => %topic_kind);
                                 }
                                 }
                             }
 
                             if !subscribed_topics.is_empty() {
-                                info!(service.log, "Subscribed to topics"; "topics" => format!("{:?}", subscribed_topics));
+                                info!(service.log, "Subscribed to topics"; "topics" => ?subscribed_topics);
                             }
                         }
                     }
@@ -545,7 +545,7 @@ fn spawn_service<T: BeaconChainTypes>(
                         }
                         Libp2pEvent::ZeroListeners => {
                             let _ = shutdown_sender.send("All listeners are closed. Unable to listen").await.map_err(|e| {
-                                warn!(service.log, "failed to send a shutdown signal"; "error" => e.to_string()
+                                warn!(service.log, "failed to send a shutdown signal"; "error" => %e
                                 )
                             });
                         }

beacon_node/network/src/sync/manager.rs

@@ -611,7 +611,7 @@ impl<T: BeaconChainTypes> SyncManager<T> {
 
         if let Some(peer_info) = self.network_globals.peers.write().peer_info_mut(peer_id) {
             let new_state = sync_type.as_sync_status(remote_sync_info);
-            let rpr = new_state.to_string();
+            let rpr = new_state.as_str();
             let was_updated = peer_info.sync_status.update(new_state);
             if was_updated {
                 debug!(self.log, "Peer transitioned sync state"; "peer_id" => %peer_id, "new_state" => rpr,

beacon_node/network/src/sync/network_context.rs

@@ -125,7 +125,7 @@ impl<T: EthSpec> SyncNetworkContext<T> {
             "Sending BlocksByRoot Request";
             "method" => "BlocksByRoot",
             "count" => request.block_roots.len(),
-            "peer" => format!("{:?}", peer_id)
+            "peer" => %peer_id
         );
         self.send_rpc_request(peer_id, Request::BlocksByRoot(request))
     }
@@ -139,11 +139,11 @@ impl<T: EthSpec> SyncNetworkContext<T> {
     }
 
     pub fn report_peer(&mut self, peer_id: PeerId, action: PeerAction) {
-        debug!(self.log, "Sync reporting peer"; "peer_id" => peer_id.to_string(), "action" => action.to_string());
+        debug!(self.log, "Sync reporting peer"; "peer_id" => %peer_id, "action" => %action);
         self.network_send
             .send(NetworkMessage::ReportPeer { peer_id, action })
             .unwrap_or_else(|e| {
-                warn!(self.log, "Could not report peer, channel failed"; "error"=> e.to_string());
+                warn!(self.log, "Could not report peer, channel failed"; "error"=> %e);
             });
     }
 
@@ -166,7 +166,7 @@ impl<T: EthSpec> SyncNetworkContext<T> {
         self.network_send
             .send(NetworkMessage::SubscribeCoreTopics)
             .unwrap_or_else(|e| {
-                warn!(self.log, "Could not subscribe to core topics."; "error" => e.to_string());
+                warn!(self.log, "Could not subscribe to core topics."; "error" => %e);
             });
     }
 

beacon_node/network/src/sync/range_sync/batch.rs

@@ -391,7 +391,7 @@ impl<T: EthSpec> slog::KV for BatchInfo<T> {
         )?;
         serializer.emit_usize("downloaded", self.failed_download_attempts.len())?;
         serializer.emit_usize("processed", self.failed_processing_attempts.len())?;
-        serializer.emit_str("state", &format!("{:?}", self.state))?;
+        serializer.emit_arguments("state", &format_args!("{:?}", self.state))?;
         slog::Result::Ok(())
     }
 }

beacon_node/network/src/sync/range_sync/chain.rs

@@ -513,7 +513,7 @@ impl<T: BeaconChainTypes> SyncingChain<T> {
                     // This should be unlikely, so we tolerate these errors, but not often.
                     let action = PeerAction::LowToleranceError;
                     warn!(self.log, "Batch failed to download. Dropping chain scoring peers";
-                        "score_adjustment" => action.to_string(),
+                        "score_adjustment" => %action,
                         "batch_epoch"=> batch_id);
                     for (peer, _) in self.peers.drain() {
                         network.report_peer(peer, action);
@@ -1028,7 +1028,7 @@ impl<T: BeaconChainTypes> slog::KV for SyncingChain<T> {
             "to",
             serializer,
         )?;
-        serializer.emit_str("end_root", &self.target_head_root.to_string())?;
+        serializer.emit_arguments("end_root", &format_args!("{}", self.target_head_root))?;
         Value::serialize(
             &self.processing_target,
             record,

beacon_node/network/src/sync/range_sync/chain_collection.rs

@@ -215,13 +215,15 @@ impl<T: BeaconChainTypes> ChainCollection<T> {
         }
     }
 
-    pub fn state(&self) -> Result<Option<(RangeSyncType, Slot /* from */, Slot /* to */)>, String> {
+    pub fn state(
+        &self,
+    ) -> Result<Option<(RangeSyncType, Slot /* from */, Slot /* to */)>, &'static str> {
         match self.state {
             RangeSyncState::Finalized(ref syncing_id) => {
                 let chain = self
                     .finalized_chains
                     .get(syncing_id)
-                    .ok_or(format!("Finalized syncing chain not found: {}", syncing_id))?;
+                    .ok_or("Finalized syncing chain not found")?;
                 Ok(Some((
                     RangeSyncType::Finalized,
                     chain.start_epoch.start_slot(T::EthSpec::slots_per_epoch()),
@@ -234,7 +236,7 @@ impl<T: BeaconChainTypes> ChainCollection<T> {
                     let chain = self
                         .head_chains
                         .get(id)
-                        .ok_or(format!("Head syncing chain not found: {}", id))?;
+                        .ok_or("Head syncing chain not found")?;
                     let start = chain.start_epoch.start_slot(T::EthSpec::slots_per_epoch());
                     let target = chain.target_head_slot;
 
@@ -242,8 +244,7 @@ impl<T: BeaconChainTypes> ChainCollection<T> {
                         .map(|(min_start, max_slot)| (min_start.min(start), max_slot.max(target)))
                         .or(Some((start, target)));
                 }
-                let (start_slot, target_slot) =
-                    range.ok_or_else(|| "Syncing head with empty head ids".to_string())?;
+                let (start_slot, target_slot) = range.ok_or("Syncing head with empty head ids")?;
                 Ok(Some((RangeSyncType::Head, start_slot, target_slot)))
             }
             RangeSyncState::Idle => Ok(None),

beacon_node/network/src/sync/range_sync/range.rs

@@ -88,7 +88,9 @@ impl<T: BeaconChainTypes> RangeSync<T> {
         }
     }
 
-    pub fn state(&self) -> Result<Option<(RangeSyncType, Slot /* from */, Slot /* to */)>, String> {
+    pub fn state(
+        &self,
+    ) -> Result<Option<(RangeSyncType, Slot /* from */, Slot /* to */)>, &'static str> {
         self.chains.state()
     }
 

beacon_node/src/cli.rs

@@ -97,6 +97,12 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                 .help("Disables UPnP support. Setting this will prevent Lighthouse from attempting to automatically establish external port mappings.")
                 .takes_value(false),
         )
+        .arg(
+            Arg::with_name("private")
+                .long("private")
+                .help("Prevents sending various client identification information.")
+                .takes_value(false),
+        )
         .arg(
             Arg::with_name("enr-udp-port")
                 .long("enr-udp-port")

beacon_node/src/config.rs

@@ -305,6 +305,8 @@ pub fn get_config<E: EthSpec>(
         }
 
         graffiti.as_bytes()
+    } else if cli_args.is_present("private") {
+        b""
     } else {
         lighthouse_version::VERSION.as_bytes()
     };
@@ -577,6 +579,10 @@ pub fn set_network_config(
         config.upnp_enabled = false;
     }
 
+    if cli_args.is_present("private") {
+        config.private = true;
+    }
+
     Ok(())
 }
 

book/src/faq.md

@@ -6,6 +6,7 @@
 - [What should I do if I lose my slashing protection database?](#what-should-i-do-if-i-lose-my-slashing-protection-database)
 - [How do I update lighthouse?](#how-do-i-update-lighthouse)
 - [I can't compile lighthouse](#i-cant-compile-lighthouse)
+- [What is "Syncing eth1 block cache"](#what-is-syncing-eth1-block-cache)
 
 
 ### Why does it take so long for a validator to be activated?
@@ -155,3 +156,21 @@ You will just also need to make sure the code you have checked out is up to date
 ### I can't compile lighthouse
 
 See [here.](./installation-source.md#troubleshooting)
+
+### What is "Syncing eth1 block cache"
+
+```
+Nov 30 21:04:28.268 WARN Syncing eth1 block cache   est_blocks_remaining: initializing deposits, msg: sync can take longer when using remote eth1 nodes, service: slot_notifier
+```
+
+This log indicates that your beacon node is downloading blocks and deposits
+from your eth1 node. When the `est_blocks_remaining` is
+`initializing_deposits`, your node is downloading deposit logs. It may stay in
+this stage for several minutes. Once the deposits logs are finished
+downloading, the `est_blocks_remaining` value will start decreasing.
+
+It is perfectly normal to see this log when starting a node for the first time
+or after being off for more than several minutes.
+
+If this log continues appearing sporadically during operation, there may be an
+issue with your eth1 endpoint.

boot_node/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "boot_node"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = "2018"
 

common/lighthouse_version/src/lib.rs

@@ -10,7 +10,7 @@ use target_info::Target;
 /// `Lighthouse/v0.2.0-1419501f2+`
 pub const VERSION: &str = git_version!(
     args = ["--always", "--dirty=+"],
-    prefix = "Lighthouse/v1.0.2-",
+    prefix = "Lighthouse/v1.0.3-",
     fallback = "unknown"
 );
 

lcli/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lcli"
 description = "Lighthouse CLI (modeled after zcli)"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 

lighthouse/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lighthouse"
-version = "1.0.2"
+version = "1.0.3"
 authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = "2018"