Merge latest unstable

beacon_node/beacon_chain/src/attestation_simulator.rs

@@ -4,7 +4,11 @@ use slot_clock::SlotClock;
 use std::sync::Arc;
 use task_executor::TaskExecutor;
 use tokio::time::sleep;
-use types::Slot;
+use types::{EthSpec, Slot};
+
+/// Don't run the attestation simulator if the head slot is this many epochs
+/// behind the wall-clock slot.
+const SYNCING_TOLERANCE_EPOCHS: u64 = 2;
 
 /// Spawns a routine which produces an unaggregated attestation at every slot.
 ///
@@ -58,33 +62,43 @@ async fn attestation_simulator_service<T: BeaconChainTypes>(
 }
 
 pub fn produce_unaggregated_attestation<T: BeaconChainTypes>(
-    inner_chain: Arc<BeaconChain<T>>,
+    chain: Arc<BeaconChain<T>>,
     current_slot: Slot,
 ) {
+    // Don't run the attestation simulator when the head slot is far behind the
+    // wall-clock slot.
+    //
+    // This helps prevent the simulator from becoming a burden by computing
+    // committees from old states.
+    let syncing_tolerance_slots = SYNCING_TOLERANCE_EPOCHS * T::EthSpec::slots_per_epoch();
+    if chain.best_slot() + syncing_tolerance_slots < current_slot {
+        return;
+    }
+
     // Since attestations for different committees are practically identical (apart from the committee index field)
     // Committee 0 is guaranteed to exist. That means there's no need to load the committee.
     let beacon_committee_index = 0;
 
     // Store the unaggregated attestation in the validator monitor for later processing
-    match inner_chain.produce_unaggregated_attestation(current_slot, beacon_committee_index) {
+    match chain.produce_unaggregated_attestation(current_slot, beacon_committee_index) {
         Ok(unaggregated_attestation) => {
             let data = &unaggregated_attestation.data;
 
             debug!(
-                inner_chain.log,
+                chain.log,
                 "Produce unagg. attestation";
                 "attestation_source" => data.source.root.to_string(),
                 "attestation_target" => data.target.root.to_string(),
             );
 
-            inner_chain
+            chain
                 .validator_monitor
                 .write()
                 .set_unaggregated_attestation(unaggregated_attestation);
         }
         Err(e) => {
             debug!(
-                inner_chain.log,
+                chain.log,
                 "Failed to simulate attestation";
                 "error" => ?e
             );

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -511,13 +511,17 @@ impl<E: EthSpec> BeaconBlockResponseWrapper<E> {
         }
     }
 
-    pub fn consensus_block_value(&self) -> u64 {
+    pub fn consensus_block_value_gwei(&self) -> u64 {
         match self {
             BeaconBlockResponseWrapper::Full(resp) => resp.consensus_block_value,
             BeaconBlockResponseWrapper::Blinded(resp) => resp.consensus_block_value,
         }
     }
 
+    pub fn consensus_block_value_wei(&self) -> Uint256 {
+        Uint256::from(self.consensus_block_value_gwei()) * 1_000_000_000
+    }
+
     pub fn is_blinded(&self) -> bool {
         matches!(self, BeaconBlockResponseWrapper::Blinded(_))
     }

beacon_node/beacon_chain/src/validator_monitor.rs

@@ -26,9 +26,9 @@ use types::consts::altair::{
     TIMELY_HEAD_FLAG_INDEX, TIMELY_SOURCE_FLAG_INDEX, TIMELY_TARGET_FLAG_INDEX,
 };
 use types::{
-    Attestation, AttesterSlashing, BeaconBlockRef, BeaconState, ChainSpec, Epoch, EthSpec, Hash256,
-    IndexedAttestation, ProposerSlashing, PublicKeyBytes, SignedAggregateAndProof,
-    SignedContributionAndProof, Slot, SyncCommitteeMessage, VoluntaryExit,
+    Attestation, AttestationData, AttesterSlashing, BeaconBlockRef, BeaconState, BeaconStateError,
+    ChainSpec, Epoch, EthSpec, Hash256, IndexedAttestation, ProposerSlashing, PublicKeyBytes,
+    SignedAggregateAndProof, SignedContributionAndProof, Slot, SyncCommitteeMessage, VoluntaryExit,
 };
 
 /// Used for Prometheus labels.
@@ -731,6 +731,8 @@ impl<T: EthSpec> ValidatorMonitor<T> {
                 // that qualifies the committee index for reward is included
                 let inclusion_delay = spec.min_attestation_inclusion_delay;
 
+                let data = &unaggregated_attestation.data;
+
                 // Get the reward indices for the unaggregated attestation or log an error
                 match get_attestation_participation_flag_indices(
                     state,
@@ -742,47 +744,12 @@ impl<T: EthSpec> ValidatorMonitor<T> {
                         let head_hit = flag_indices.contains(&TIMELY_HEAD_FLAG_INDEX);
                         let target_hit = flag_indices.contains(&TIMELY_TARGET_FLAG_INDEX);
                         let source_hit = flag_indices.contains(&TIMELY_SOURCE_FLAG_INDEX);
-
-                        if head_hit {
-                            metrics::inc_counter(
-                                &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_HEAD_ATTESTER_HIT,
-                            );
-                        } else {
-                            metrics::inc_counter(
-                            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_HEAD_ATTESTER_MISS,
-                            );
-                        }
-                        if target_hit {
-                            metrics::inc_counter(
-                            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_TARGET_ATTESTER_HIT,
-                            );
-                        } else {
-                            metrics::inc_counter(
-                            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_TARGET_ATTESTER_MISS,
-                            );
-                        }
-                        if source_hit {
-                            metrics::inc_counter(
-                            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_SOURCE_ATTESTER_HIT,
-                            );
-                        } else {
-                            metrics::inc_counter(
-                            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_SOURCE_ATTESTER_MISS,
-                            );
-                        }
-
-                        let data = &unaggregated_attestation.data;
-                        debug!(
-                            self.log,
-                            "Simulated attestation evaluated";
-                            "attestation_source" => ?data.source.root,
-                            "attestation_target" => ?data.target.root,
-                            "attestation_head" => ?data.beacon_block_root,
-                            "attestation_slot" => ?data.slot,
-                            "source_hit" => source_hit,
-                            "target_hit" => target_hit,
-                            "head_hit" => head_hit,
-                        );
+                        register_simulated_attestation(
+                            data, head_hit, target_hit, source_hit, &self.log,
+                        )
+                    }
+                    Err(BeaconStateError::IncorrectAttestationSource) => {
+                        register_simulated_attestation(data, false, false, false, &self.log)
                     }
                     Err(err) => {
                         error!(
@@ -2054,6 +2021,46 @@ impl<T: EthSpec> ValidatorMonitor<T> {
     }
 }
 
+fn register_simulated_attestation(
+    data: &AttestationData,
+    head_hit: bool,
+    target_hit: bool,
+    source_hit: bool,
+    log: &Logger,
+) {
+    if head_hit {
+        metrics::inc_counter(&metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_HEAD_ATTESTER_HIT);
+    } else {
+        metrics::inc_counter(&metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_HEAD_ATTESTER_MISS);
+    }
+    if target_hit {
+        metrics::inc_counter(&metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_TARGET_ATTESTER_HIT);
+    } else {
+        metrics::inc_counter(
+            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_TARGET_ATTESTER_MISS,
+        );
+    }
+    if source_hit {
+        metrics::inc_counter(&metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_SOURCE_ATTESTER_HIT);
+    } else {
+        metrics::inc_counter(
+            &metrics::VALIDATOR_MONITOR_ATTESTATION_SIMULATOR_SOURCE_ATTESTER_MISS,
+        );
+    }
+
+    debug!(
+        log,
+        "Simulated attestation evaluated";
+        "attestation_source" => ?data.source.root,
+        "attestation_target" => ?data.target.root,
+        "attestation_head" => ?data.beacon_block_root,
+        "attestation_slot" => ?data.slot,
+        "source_hit" => source_hit,
+        "target_hit" => target_hit,
+        "head_hit" => head_hit,
+    );
+}
+
 /// Returns the duration since the unix epoch.
 pub fn timestamp_now() -> Duration {
     SystemTime::now()

beacon_node/client/src/builder.rs

@@ -35,6 +35,7 @@ use std::net::TcpListener;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
+use std::time::{SystemTime, UNIX_EPOCH};
 use timer::spawn_timer;
 use tokio::sync::oneshot;
 use types::{
@@ -45,6 +46,11 @@ use types::{
 /// Interval between polling the eth1 node for genesis information.
 pub const ETH1_GENESIS_UPDATE_INTERVAL_MILLIS: u64 = 7_000;
 
+/// Reduces the blob availability period by some epochs. Helps prevent the user
+/// from starting a genesis sync so near to the blob pruning window that blobs
+/// have been pruned before they can manage to sync the chain.
+const BLOB_AVAILABILITY_REDUCTION_EPOCHS: u64 = 2;
+
 /// Builds a `Client` instance.
 ///
 /// ## Notes
@@ -252,6 +258,45 @@ where
 
                 let genesis_state = genesis_state(&runtime_context, &config, log).await?;
 
+                // If the user has not explicitly allowed genesis sync, prevent
+                // them from trying to sync from genesis if we're outside of the
+                // blob P2P availability window.
+                //
+                // It doesn't make sense to try and sync the chain if we can't
+                // verify blob availability by downloading blobs from the P2P
+                // network. The user should do a checkpoint sync instead.
+                if !config.allow_insecure_genesis_sync {
+                    if let Some(deneb_fork_epoch) = spec.deneb_fork_epoch {
+                        let now = SystemTime::now()
+                            .duration_since(UNIX_EPOCH)
+                            .map_err(|e| format!("Unable to read system time: {e:}"))?
+                            .as_secs();
+                        let genesis_time = genesis_state.genesis_time();
+                        let deneb_time =
+                            genesis_time + (deneb_fork_epoch.as_u64() * spec.seconds_per_slot);
+
+                        // Shrink the blob availability window so users don't start
+                        // a sync right before blobs start to disappear from the P2P
+                        // network.
+                        let reduced_p2p_availability_epochs = spec
+                            .min_epochs_for_blob_sidecars_requests
+                            .saturating_sub(BLOB_AVAILABILITY_REDUCTION_EPOCHS);
+                        let blob_availability_window = reduced_p2p_availability_epochs
+                            * TEthSpec::slots_per_epoch()
+                            * spec.seconds_per_slot;
+
+                        if now > deneb_time + blob_availability_window {
+                            return Err(
+                                    "Syncing from genesis is insecure and incompatible with data availability checks. \
+                                    You should instead perform a checkpoint sync from a trusted node using the --checkpoint-sync-url option. \
+                                    For a list of public endpoints, see: https://eth-clients.github.io/checkpoint-sync-endpoints/ \
+                                    Alternatively, use --allow-insecure-genesis-sync if the risks are understood."
+                                        .to_string(),
+                                );
+                        }
+                    }
+                }
+
                 builder.genesis_state(genesis_state).map(|v| (v, None))?
             }
             ClientGenesis::WeakSubjSszBytes {

beacon_node/client/src/config.rs

@@ -78,6 +78,7 @@ pub struct Config {
     pub beacon_processor: BeaconProcessorConfig,
     pub genesis_state_url: Option<String>,
     pub genesis_state_url_timeout: Duration,
+    pub allow_insecure_genesis_sync: bool,
 }
 
 impl Default for Config {
@@ -108,6 +109,7 @@ impl Default for Config {
             genesis_state_url: <_>::default(),
             // This default value should always be overwritten by the CLI default value.
             genesis_state_url_timeout: Duration::from_secs(60),
+            allow_insecure_genesis_sync: false,
         }
     }
 }

beacon_node/http_api/src/produce_block.rs

@@ -58,7 +58,7 @@ pub async fn produce_block_v3<T: BeaconChainTypes>(
         .produce_block_with_verification(
             randao_reveal,
             slot,
-            query.graffiti.map(Into::into),
+            query.graffiti,
             randao_verification,
             query.builder_boost_factor,
             BlockProductionVersion::V3,
@@ -80,7 +80,7 @@ pub fn build_response_v3<T: BeaconChainTypes>(
         .fork_name(&chain.spec)
         .map_err(inconsistent_fork_rejection)?;
     let execution_payload_value = block_response.execution_payload_value();
-    let consensus_block_value = block_response.consensus_block_value();
+    let consensus_block_value = block_response.consensus_block_value_wei();
     let execution_payload_blinded = block_response.is_blinded();
 
     let metadata = ProduceBlockV3Metadata {

beacon_node/http_api/src/version.rs

@@ -93,7 +93,7 @@ pub fn add_execution_payload_value_header<T: Reply>(
 /// Add the `Eth-Consensus-Block-Value` header to a response.
 pub fn add_consensus_block_value_header<T: Reply>(
     reply: T,
-    consensus_payload_value: u64,
+    consensus_payload_value: Uint256,
 ) -> Response {
     reply::with_header(
         reply,

beacon_node/src/cli.rs

@@ -955,6 +955,16 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                 .takes_value(true)
                 .default_value("180")
         )
+        .arg(
+            Arg::with_name("allow-insecure-genesis-sync")
+                .long("allow-insecure-genesis-sync")
+                .help("Enable syncing from genesis, which is generally insecure and incompatible with data availability checks. \
+                    Checkpoint syncing is the preferred method for syncing a node. \
+                    Only use this flag when testing. DO NOT use on mainnet!")
+                .conflicts_with("checkpoint-sync-url")
+                .conflicts_with("checkpoint-state")
+                .takes_value(false)
+        )
         .arg(
             Arg::with_name("reconstruct-historic-states")
                 .long("reconstruct-historic-states")

beacon_node/src/config.rs

@@ -497,6 +497,8 @@ pub fn get_config<E: EthSpec>(
         None
     };
 
+    client_config.allow_insecure_genesis_sync = cli_args.is_present("allow-insecure-genesis-sync");
+
     client_config.genesis = if eth2_network_config.genesis_state_is_known() {
         // Set up weak subjectivity sync, or start from the hardcoded genesis state.
         if let (Some(initial_state_path), Some(initial_block_path)) = (

book/src/help_bn.md

@@ -9,6 +9,10 @@ USAGE:
     lighthouse beacon_node [FLAGS] [OPTIONS]
 
 FLAGS:
+        --allow-insecure-genesis-sync          Enable syncing from genesis, which is generally insecure and incompatible
+                                               with data availability checks. Checkpoint syncing is the preferred method
+                                               for syncing a node. Only use this flag when testing. DO NOT use on
+                                               mainnet!
         --always-prefer-builder-payload        This flag is deprecated and has no effect.
         --always-prepare-payload               Send payload attributes with every fork choice update. This is intended
                                                for use by block builders, relays and developers. You should set a fee

common/eth2/src/types.rs

@@ -1554,9 +1554,10 @@ pub struct ProduceBlockV3Metadata {
     )]
     pub consensus_version: ForkName,
     pub execution_payload_blinded: bool,
+    #[serde(with = "serde_utils::u256_dec")]
     pub execution_payload_value: Uint256,
-    #[serde(with = "serde_utils::quoted_u64")]
-    pub consensus_block_value: u64,
+    #[serde(with = "serde_utils::u256_dec")]
+    pub consensus_block_value: Uint256,
 }
 
 impl<T: EthSpec> FullBlockContents<T> {
@@ -1707,7 +1708,7 @@ impl TryFrom<&HeaderMap> for ProduceBlockV3Metadata {
             })?;
         let consensus_block_value =
             parse_required_header(headers, CONSENSUS_BLOCK_VALUE_HEADER, |s| {
-                s.parse::<u64>()
+                s.parse::<Uint256>()
                     .map_err(|e| format!("invalid {CONSENSUS_BLOCK_VALUE_HEADER}: {e:?}"))
             })?;
 

lighthouse/tests/beacon_node.rs

@@ -92,6 +92,22 @@ fn staking_flag() {
         });
 }
 
+#[test]
+fn allow_insecure_genesis_sync() {
+    CommandLineTest::new()
+        .run_with_zero_port()
+        .with_config(|config| {
+            assert_eq!(config.allow_insecure_genesis_sync, false);
+        });
+
+    CommandLineTest::new()
+        .flag("allow-insecure-genesis-sync", None)
+        .run_with_zero_port()
+        .with_config(|config| {
+            assert_eq!(config.allow_insecure_genesis_sync, true);
+        });
+}
+
 #[test]
 fn wss_checkpoint_flag() {
     let state = Some(Checkpoint {