Merge branch 'unstable' into merge-unstable-to-deneb-20230808

# Conflicts: # Cargo.lock # beacon_node/beacon_chain/src/lib.rs # beacon_node/execution_layer/src/engine_api.rs # beacon_node/execution_layer/src/engine_api/http.rs # beacon_node/execution_layer/src/test_utils/mod.rs # beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs # beacon_node/lighthouse_network/src/rpc/handler.rs # beacon_node/lighthouse_network/src/rpc/protocol.rs # beacon_node/lighthouse_network/src/service/utils.rs # beacon_node/lighthouse_network/tests/rpc_tests.rs # beacon_node/network/Cargo.toml # beacon_node/network/src/network_beacon_processor/tests.rs # lcli/src/parse_ssz.rs # scripts/cross/Dockerfile # validator_client/src/block_service.rs # validator_client/src/validator_store.rs
2026-03-14 18:32:42 +00:00 · 2023-08-08 16:33:32 +10:00
parent 731b7e7af5 1373dcf076
commit ec416df061
161 changed files with 8729 additions and 3368 deletions
--- a/lcli/src/main.rs
+++ b/lcli/src/main.rs
@@ -977,7 +977,9 @@ fn run<T: EthSpec>(
                .map_err(|e| format!("Failed to skip slots: {}", e))
        }
        ("pretty-ssz", Some(matches)) => {
-            run_parse_ssz::<T>(matches).map_err(|e| format!("Failed to pretty print hex: {}", e))
+            let network_config = get_network_config()?;
+            run_parse_ssz::<T>(network_config, matches)
+                .map_err(|e| format!("Failed to pretty print hex: {}", e))
        }
        ("deploy-deposit-contract", Some(matches)) => {
            deploy_deposit_contract::run::<T>(env, matches)
--- a/lcli/src/parse_ssz.rs
+++ b/lcli/src/parse_ssz.rs
@@ -1,5 +1,6 @@
 use clap::ArgMatches;
 use clap_utils::parse_required;
+use eth2_network_config::Eth2NetworkConfig;
 use serde::Serialize;
 use snap::raw::Decoder;
 use ssz::Decode;
@@ -26,7 +27,10 @@ impl FromStr for OutputFormat {
    }
 }

-pub fn run_parse_ssz<T: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
+pub fn run_parse_ssz<T: EthSpec>(
+    network_config: Eth2NetworkConfig,
+    matches: &ArgMatches,
+) -> Result<(), String> {
    let type_str = matches.value_of("type").ok_or("No type supplied")?;
    let filename = matches.value_of("ssz-file").ok_or("No file supplied")?;
    let format = parse_required(matches, "format")?;
@@ -44,51 +48,86 @@ pub fn run_parse_ssz<T: EthSpec>(matches: &ArgMatches) -> Result<(), String> {
        bytes
    };

-    info!("Using {} spec", T::spec_name());
-    info!("Type: {:?}", type_str);
+    let spec = &network_config.chain_spec::<T>()?;
+    info!(
+        "Using {} network config ({} preset)",
+        spec.config_name.as_deref().unwrap_or("unknown"),
+        T::spec_name()
+    );
+    info!("Type: {type_str}");

+    // More fork-specific decoders may need to be added in future, but shouldn't be 100% necessary,
+    // as the fork-generic decoder will always be available (requires correct --network flag).
    match type_str {
-        "signed_block_base" => decode_and_print::<SignedBeaconBlockBase<T>>(&bytes, format)?,
-        "signed_block_altair" => decode_and_print::<SignedBeaconBlockAltair<T>>(&bytes, format)?,
-        "signed_block_merge" => decode_and_print::<SignedBeaconBlockMerge<T>>(&bytes, format)?,
-        "signed_block_capella" => decode_and_print::<SignedBeaconBlockCapella<T>>(&bytes, format)?,
-        "signed_block_deneb" => decode_and_print::<SignedBeaconBlockDeneb<T>>(&bytes, format)?,
-        "block_base" => decode_and_print::<BeaconBlockBase<T>>(&bytes, format)?,
-        "block_altair" => decode_and_print::<BeaconBlockAltair<T>>(&bytes, format)?,
-        "block_merge" => decode_and_print::<BeaconBlockMerge<T>>(&bytes, format)?,
-        "block_capella" => decode_and_print::<BeaconBlockCapella<T>>(&bytes, format)?,
-        "block_deneb" => decode_and_print::<BeaconBlockDeneb<T>>(&bytes, format)?,
-        "state_base" => decode_and_print::<BeaconStateBase<T>>(&bytes, format)?,
-        "state_altair" => decode_and_print::<BeaconStateAltair<T>>(&bytes, format)?,
-        "state_merge" => decode_and_print::<BeaconStateMerge<T>>(&bytes, format)?,
-        "state_capella" => decode_and_print::<BeaconStateCapella<T>>(&bytes, format)?,
-        "state_deneb" => decode_and_print::<BeaconStateDeneb<T>>(&bytes, format)?,
-        "blob_sidecar" => decode_and_print::<BlobSidecar<T>>(&bytes, format)?,
+        "SignedBeaconBlock" => decode_and_print::<SignedBeaconBlock<T>>(
+            &bytes,
+            |bytes| SignedBeaconBlock::from_ssz_bytes(bytes, spec),
+            format,
+        )?,
+        "SignedBeaconBlockBase" | "SignedBeaconBlockPhase0" => {
+            decode_and_print(&bytes, SignedBeaconBlockBase::<T>::from_ssz_bytes, format)?
+        }
+        "SignedBeaconBlockAltair" => {
+            decode_and_print(&bytes, SignedBeaconBlockAltair::<T>::from_ssz_bytes, format)?
+        }
+        "SignedBeaconBlockMerge" | "SignedBeaconBlockBellatrix" => {
+            decode_and_print(&bytes, SignedBeaconBlockMerge::<T>::from_ssz_bytes, format)?
+        }
+        "SignedBeaconBlockCapella" => decode_and_print(
+            &bytes,
+            SignedBeaconBlockCapella::<T>::from_ssz_bytes,
+            format,
+        )?,
+        "SignedBeaconBlockDeneb" => {
+            decode_and_print(&bytes, SignedBeaconBlockDeneb::<T>::from_ssz_bytes, format)?
+        }
+        "BeaconState" => decode_and_print::<BeaconState<T>>(
+            &bytes,
+            |bytes| BeaconState::from_ssz_bytes(bytes, spec),
+            format,
+        )?,
+        "BeaconStateBase" | "BeaconStatePhase0" => {
+            decode_and_print(&bytes, BeaconStateBase::<T>::from_ssz_bytes, format)?
+        }
+        "BeaconStateAltair" => {
+            decode_and_print(&bytes, BeaconStateAltair::<T>::from_ssz_bytes, format)?
+        }
+        "BeaconStateMerge" | "BeaconStateBellatrix" => {
+            decode_and_print(&bytes, BeaconStateMerge::<T>::from_ssz_bytes, format)?
+        }
+        "BeaconStateCapella" => {
+            decode_and_print(&bytes, BeaconStateCapella::<T>::from_ssz_bytes, format)?
+        }
+        "BeaconStateDeneb" => {
+            decode_and_print(&bytes, BeaconStateDeneb::<T>::from_ssz_bytes, format)?
+        }
+        "BlobSidecar" => decode_and_print(&bytes, BlobSidecar::<T>::from_ssz_bytes, format)?,
        other => return Err(format!("Unknown type: {}", other)),
    };

    Ok(())
 }

-fn decode_and_print<T: Decode + Serialize>(
+fn decode_and_print<T: Serialize>(
    bytes: &[u8],
+    decoder: impl FnOnce(&[u8]) -> Result<T, ssz::DecodeError>,
    output_format: OutputFormat,
 ) -> Result<(), String> {
-    let item = T::from_ssz_bytes(bytes).map_err(|e| format!("SSZ decode failed: {:?}", e))?;
+    let item = decoder(bytes).map_err(|e| format!("SSZ decode failed: {e:?}"))?;

    match output_format {
        OutputFormat::Json => {
            println!(
                "{}",
                serde_json::to_string(&item)
-                    .map_err(|e| format!("Unable to write object to JSON: {:?}", e))?
+                    .map_err(|e| format!("Unable to write object to JSON: {e:?}"))?
            );
        }
        OutputFormat::Yaml => {
            println!(
                "{}",
                serde_yaml::to_string(&item)
-                    .map_err(|e| format!("Unable to write object to YAML: {:?}", e))?
+                    .map_err(|e| format!("Unable to write object to YAML: {e:?}"))?
            );
        }
    }
--- a/lcli/src/transition_blocks.rs
+++ b/lcli/src/transition_blocks.rs
@@ -73,9 +73,10 @@ use eth2::{
 };
 use eth2_network_config::Eth2NetworkConfig;
 use ssz::Encode;
+use state_processing::state_advance::complete_state_advance;
 use state_processing::{
-    block_signature_verifier::BlockSignatureVerifier, per_block_processing, per_slot_processing,
-    BlockSignatureStrategy, ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
+    block_signature_verifier::BlockSignatureVerifier, per_block_processing, BlockSignatureStrategy,
+    ConsensusContext, StateProcessingStrategy, VerifyBlockRoot,
 };
 use std::borrow::Cow;
 use std::fs::File;
@@ -332,10 +333,8 @@ fn do_transition<T: EthSpec>(

    // Transition the parent state to the block slot.
    let t = Instant::now();
-    for i in pre_state.slot().as_u64()..block.slot().as_u64() {
-        per_slot_processing(&mut pre_state, Some(state_root), spec)
-            .map_err(|e| format!("Failed to advance slot on iteration {}: {:?}", i, e))?;
-    }
+    complete_state_advance(&mut pre_state, Some(state_root), block.slot(), spec)
+        .map_err(|e| format!("Unable to perform complete advance: {e:?}"))?;
    debug!("Slot processing: {:?}", t.elapsed());

    let t = Instant::now();