cleanup

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4591,11 +4591,10 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         //FIXME(sean)
         // - add a new timer for processing here
         if let Some(blobs) = blobs_opt {
-            let kzg = if let Some(kzg) = &self.kzg {
-                kzg
-            } else {
-                return Err(BlockProductionError::TrustedSetupNotInitialized);
-            };
+            let kzg = self
+                .kzg
+                .as_ref()
+                .ok_or(BlockProductionError::TrustedSetupNotInitialized)?;
             let kzg_aggregated_proof =
                 kzg_utils::compute_aggregate_kzg_proof::<T::EthSpec>(&kzg, &blobs)
                     .map_err(|e| BlockProductionError::KzgError(e))?;

beacon_node/beacon_chain/src/blob_verification.rs

@@ -60,12 +60,16 @@ pub enum BlobError {
     BeaconChainError(BeaconChainError),
     /// No blobs for the specified block where we would expect blobs.
     UnavailableBlobs,
+    /// Blobs provided for a pre-Eip4844 fork.
     InconsistentFork,
 }
 
 impl From<BlobReconstructionError> for BlobError {
-    fn from(_: BlobReconstructionError) -> Self {
-        BlobError::UnavailableBlobs
+    fn from(e: BlobReconstructionError) -> Self {
+        match e {
+            BlobReconstructionError::UnavailableBlobs => BlobError::UnavailableBlobs,
+            BlobReconstructionError::InconsistentFork => BlobError::InconsistentFork,
+        }
     }
 }
 
@@ -119,7 +123,6 @@ fn verify_data_availability<T: BeaconChainTypes>(
     block_root: Hash256,
     chain: &BeaconChain<T>,
 ) -> Result<(), BlobError> {
-    // Validate commitments agains transactions in the block.
     if verify_kzg_commitments_against_transactions::<T::EthSpec>(transactions, kzg_commitments)
         .is_err()
     {
@@ -148,7 +151,7 @@ fn verify_data_availability<T: BeaconChainTypes>(
 
 /// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobsSidecar`]. This makes no
 /// claims about data availability and should not be used in consensus. This struct is useful in
-/// networking when we want to send blocks around without adding consensus logic.
+/// networking when we want to send blocks around without consensus checks.
 #[derive(Clone, Debug, Derivative)]
 #[derivative(PartialEq, Hash(bound = "E: EthSpec"))]
 pub enum BlockWrapper<E: EthSpec> {
@@ -252,9 +255,10 @@ impl<T: BeaconChainTypes> IntoAvailableBlock<T> for BlockWrapper<T::EthSpec> {
     }
 }
 
-/// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobsSidecar`]. This newtype
-/// wraps the `BlockWrapperInner` to ensure blobs cannot be accessed via an enum match. This would
-/// circumvent empty blob reconstruction when accessing blobs.
+/// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobsSidecar`].  An
+/// `AvailableBlock` has passed any required data availability checks and should be used in
+/// consensus. This newtype wraps `AvailableBlockInner` to ensure data availability checks
+/// cannot be circumvented on construction.
 #[derive(Clone, Debug, Derivative)]
 #[derivative(PartialEq, Hash(bound = "E: EthSpec"))]
 pub struct AvailableBlock<E: EthSpec>(AvailableBlockInner<E>);
@@ -262,7 +266,7 @@ pub struct AvailableBlock<E: EthSpec>(AvailableBlockInner<E>);
 /// A wrapper over a [`SignedBeaconBlock`] or a [`SignedBeaconBlockAndBlobsSidecar`].
 #[derive(Clone, Debug, Derivative)]
 #[derivative(PartialEq, Hash(bound = "E: EthSpec"))]
-pub enum AvailableBlockInner<E: EthSpec> {
+enum AvailableBlockInner<E: EthSpec> {
     Block(Arc<SignedBeaconBlock<E>>),
     BlockAndBlob(SignedBeaconBlockAndBlobsSidecar<E>),
 }

beacon_node/beacon_chain/src/block_verification.rs

@@ -69,7 +69,7 @@ use eth2::types::EventKind;
 use execution_layer::PayloadStatus;
 use fork_choice::{AttestationFromBlock, PayloadVerificationStatus};
 use parking_lot::RwLockReadGuard;
-use proto_array::{Block as ProtoBlock};
+use proto_array::Block as ProtoBlock;
 use safe_arith::ArithError;
 use slog::{debug, error, warn, Logger};
 use slot_clock::SlotClock;
@@ -601,6 +601,7 @@ pub fn signature_verify_chain_segment<T: BeaconChainTypes>(
 
         //FIXME(sean) batch kzg verification
         let available_block = block.clone().into_available_block(*block_root, chain)?;
+        consensus_context = consensus_context.set_kzg_commitments_consistent(true);
 
         // Save the block and its consensus context. The context will have had its proposer index
         // and attesting indices filled in, which can be used to accelerate later block processing.
@@ -927,7 +928,8 @@ impl<T: BeaconChainTypes> GossipVerifiedBlock<T> {
         // Having checked the proposer index and the block root we can cache them.
         let consensus_context = ConsensusContext::new(available_block.slot())
             .set_current_block_root(block_root)
-            .set_proposer_index(available_block.as_block().message().proposer_index());
+            .set_proposer_index(available_block.as_block().message().proposer_index())
+            .set_kzg_commitments_consistent(true);
 
         Ok(Self {
             block: available_block,
@@ -999,8 +1001,10 @@ impl<T: BeaconChainTypes> SignatureVerifiedBlock<T> {
 
         let mut signature_verifier = get_signature_verifier(&state, &pubkey_cache, &chain.spec);
 
-        let mut consensus_context =
-            ConsensusContext::new(block.slot()).set_current_block_root(block_root);
+        let mut consensus_context = ConsensusContext::new(block.slot())
+            .set_current_block_root(block_root)
+            // An `AvailabileBlock is passed in here, so we know this check has been run.`
+            .set_kzg_commitments_consistent(true);
 
         signature_verifier.include_all_signatures(block.as_block(), &mut consensus_context)?;
 

beacon_node/http_api/src/publish_blocks.rs

@@ -60,10 +60,18 @@ pub async fn publish_block<T: BeaconChainTypes>(
     let delay = get_block_delay_ms(seen_timestamp, block.message(), &chain.slot_clock);
     metrics::observe_duration(&metrics::HTTP_API_BLOCK_BROADCAST_DELAY_TIMES, delay);
 
-    //FIXME(sean) handle errors
-    let available_block = wrapped_block
-        .into_available_block(block_root, &chain)
-        .unwrap();
+    let available_block = match wrapped_block.into_available_block(block_root, &chain) {
+        Ok(available_block) => available_block,
+        Err(e) => {
+            let msg = format!("{:?}", e);
+            error!(
+                log,
+                "Invalid block provided to HTTP API";
+                "reason" => &msg
+            );
+            return Err(warp_utils::reject::broadcast_without_import(msg));
+        }
+    };
 
     match chain
         .process_block(