Revert "Clean capella (#4019)"

This reverts commit 047c754.

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -4106,6 +4106,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             None
         };
 
+        //FIXME(sean) waiting for the BN<>EE api for this to stabilize
+        let kzg_commitments = vec![];
+
         // Part 3/3 (blocking)
         //
         // Perform the final steps of combining all the parts and computing the state root.
@@ -4116,6 +4119,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     chain.complete_partial_beacon_block(
                         partial_beacon_block,
                         block_contents,
+                        kzg_commitments,
                         verification,
                     )
                 },
@@ -4186,7 +4190,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         // allows it to run concurrently with things like attestation packing.
         let prepare_payload_handle = match &state {
             BeaconState::Base(_) | BeaconState::Altair(_) => None,
-            BeaconState::Merge(_) | BeaconState::Capella(_) => {
+            BeaconState::Merge(_) | BeaconState::Capella(_) | BeaconState::Eip4844(_) => {
                 let prepare_payload_handle =
                     get_execution_payload(self.clone(), &state, proposer_index, builder_params)?;
                 Some(prepare_payload_handle)
@@ -4369,6 +4373,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         partial_beacon_block: PartialBeaconBlock<T::EthSpec, Payload>,
         block_contents: Option<BlockProposalContents<T::EthSpec, Payload>>,
+        kzg_commitments: Vec<KzgCommitment>,
         verification: ProduceBlockVerification,
     ) -> Result<BeaconBlockAndState<T::EthSpec, Payload>, BlockProductionError> {
         let PartialBeaconBlock {
@@ -4476,6 +4481,31 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     bls_to_execution_changes: bls_to_execution_changes.into(),
                 },
             }),
+            BeaconState::Eip4844(_) => BeaconBlock::Eip4844(BeaconBlockEip4844 {
+                slot,
+                proposer_index,
+                parent_root,
+                state_root: Hash256::zero(),
+                body: BeaconBlockBodyEip4844 {
+                    randao_reveal,
+                    eth1_data,
+                    graffiti,
+                    proposer_slashings: proposer_slashings.into(),
+                    attester_slashings: attester_slashings.into(),
+                    attestations: attestations.into(),
+                    deposits: deposits.into(),
+                    voluntary_exits: voluntary_exits.into(),
+                    sync_aggregate: sync_aggregate
+                        .ok_or(BlockProductionError::MissingSyncAggregate)?,
+                    execution_payload: block_contents
+                        .ok_or(BlockProductionError::MissingExecutionPayload)?
+                        .to_payload()
+                        .try_into()
+                        .map_err(|_| BlockProductionError::InvalidPayloadFork)?,
+                    bls_to_execution_changes: bls_to_execution_changes.into(),
+                    blob_kzg_commitments: VariableList::from(kzg_commitments),
+                },
+            }),
         };
 
         let block = SignedBeaconBlock::from_block(
@@ -4730,7 +4760,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
 
         let withdrawals = match self.spec.fork_name_at_slot::<T::EthSpec>(prepare_slot) {
             ForkName::Base | ForkName::Altair | ForkName::Merge => None,
-            ForkName::Capella => {
+            ForkName::Capella | ForkName::Eip4844 => {
                 // We must use the advanced state because balances can change at epoch boundaries
                 // and balances affect withdrawals.
                 // FIXME(mark)

beacon_node/beacon_chain/src/blob_verification.rs

@@ -0,0 +1,136 @@
+use derivative::Derivative;
+use slot_clock::SlotClock;
+
+use crate::beacon_chain::{BeaconChain, BeaconChainTypes, MAXIMUM_GOSSIP_CLOCK_DISPARITY};
+use crate::BeaconChainError;
+use bls::PublicKey;
+use types::{consts::eip4844::BLS_MODULUS, BeaconStateError, BlobsSidecar, Slot};
+
+pub enum BlobError {
+    /// The blob sidecar is from a slot that is later than the current slot (with respect to the
+    /// gossip clock disparity).
+    ///
+    /// ## Peer scoring
+    ///
+    /// Assuming the local clock is correct, the peer has sent an invalid message.
+    FutureSlot {
+        message_slot: Slot,
+        latest_permissible_slot: Slot,
+    },
+    /// The blob sidecar is from a slot that is prior to the earliest permissible slot (with
+    /// respect to the gossip clock disparity).
+    ///
+    /// ## Peer scoring
+    ///
+    /// Assuming the local clock is correct, the peer has sent an invalid message.
+    PastSlot {
+        message_slot: Slot,
+        earliest_permissible_slot: Slot,
+    },
+
+    /// The blob sidecar contains an incorrectly formatted `BLSFieldElement` > `BLS_MODULUS`.
+    ///
+    ///
+    /// ## Peer scoring
+    ///
+    /// The peer has sent an invalid message.
+    BlobOutOfRange { blob_index: usize },
+
+    /// The blob sidecar contains a KZGCommitment that is not a valid G1 point on
+    /// the bls curve.
+    ///
+    /// ## Peer scoring
+    ///
+    /// The peer has sent an invalid message.
+    InvalidKZGCommitment,
+    /// The proposal signature in invalid.
+    ///
+    /// ## Peer scoring
+    ///
+    /// The signature on the blob sidecar invalid and the peer is faulty.
+    ProposalSignatureInvalid,
+
+    /// A blob sidecar for this proposer and slot has already been observed.
+    ///
+    /// ## Peer scoring
+    ///
+    /// The `proposer` has already proposed a sidecar at this slot. The existing sidecar may or may not
+    /// be equal to the given sidecar.
+    RepeatSidecar { proposer: u64, slot: Slot },
+
+    /// There was an error whilst processing the sync contribution. It is not known if it is valid or invalid.
+    ///
+    /// ## Peer scoring
+    ///
+    /// We were unable to process this sync committee message due to an internal error. It's unclear if the
+    /// sync committee message is valid.
+    BeaconChainError(BeaconChainError),
+}
+
+impl From<BeaconChainError> for BlobError {
+    fn from(e: BeaconChainError) -> Self {
+        BlobError::BeaconChainError(e)
+    }
+}
+
+impl From<BeaconStateError> for BlobError {
+    fn from(e: BeaconStateError) -> Self {
+        BlobError::BeaconChainError(BeaconChainError::BeaconStateError(e))
+    }
+}
+
+/// A wrapper around a `BlobsSidecar` that indicates it has been verified w.r.t the corresponding
+/// `SignedBeaconBlock`.
+#[derive(Derivative)]
+#[derivative(Debug(bound = "T: BeaconChainTypes"))]
+pub struct VerifiedBlobsSidecar<'a, T: BeaconChainTypes> {
+    pub blob_sidecar: &'a BlobsSidecar<T::EthSpec>,
+}
+
+impl<'a, T: BeaconChainTypes> VerifiedBlobsSidecar<'a, T> {
+    pub fn verify(
+        blob_sidecar: &'a BlobsSidecar<T::EthSpec>,
+        chain: &BeaconChain<T>,
+    ) -> Result<Self, BlobError> {
+        let blob_slot = blob_sidecar.beacon_block_slot;
+        // Do not gossip or process blobs from future or past slots.
+        let latest_permissible_slot = chain
+            .slot_clock
+            .now_with_future_tolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY)
+            .ok_or(BeaconChainError::UnableToReadSlot)?;
+        if blob_slot > latest_permissible_slot {
+            return Err(BlobError::FutureSlot {
+                message_slot: latest_permissible_slot,
+                latest_permissible_slot: blob_slot,
+            });
+        }
+
+        let earliest_permissible_slot = chain
+            .slot_clock
+            .now_with_past_tolerance(MAXIMUM_GOSSIP_CLOCK_DISPARITY)
+            .ok_or(BeaconChainError::UnableToReadSlot)?;
+        if blob_slot > earliest_permissible_slot {
+            return Err(BlobError::PastSlot {
+                message_slot: earliest_permissible_slot,
+                earliest_permissible_slot: blob_slot,
+            });
+        }
+
+        // Verify that blobs are properly formatted
+        //TODO: add the check while constructing a Blob type from bytes instead of after
+        for (i, blob) in blob_sidecar.blobs.iter().enumerate() {
+            if blob.iter().any(|b| *b >= *BLS_MODULUS) {
+                return Err(BlobError::BlobOutOfRange { blob_index: i });
+            }
+        }
+
+        // Verify that the KZG proof is a valid G1 point
+        if PublicKey::deserialize(&blob_sidecar.kzg_aggregate_proof.0).is_err() {
+            return Err(BlobError::InvalidKZGCommitment);
+        }
+
+        // TODO: Check that we have not already received a sidecar with a valid signature for this slot.
+
+        Ok(Self { blob_sidecar })
+    }
+}

beacon_node/beacon_chain/src/errors.rs

@@ -258,6 +258,11 @@ pub enum BlockProductionError {
     BlockingFailed(execution_layer::Error),
     TerminalPoWBlockLookupFailed(execution_layer::Error),
     GetPayloadFailed(execution_layer::Error),
+    GetBlobsFailed(execution_layer::Error),
+    BlobPayloadMismatch {
+        blob_block_hash: ExecutionBlockHash,
+        payload_block_hash: ExecutionBlockHash,
+    },
     FailedToReadFinalizedBlock(store::Error),
     MissingFinalizedBlock(Hash256),
     BlockTooLarge(usize),

beacon_node/beacon_chain/src/execution_payload.rs

@@ -406,7 +406,9 @@ pub fn get_execution_payload<
     let latest_execution_payload_header_block_hash =
         state.latest_execution_payload_header()?.block_hash();
     let withdrawals = match state {
-        &BeaconState::Capella(_) => Some(get_expected_withdrawals(state, spec)?.into()),
+        &BeaconState::Capella(_) | &BeaconState::Eip4844(_) => {
+            Some(get_expected_withdrawals(state, spec)?.into())
+        }
         &BeaconState::Merge(_) => None,
         // These shouldn't happen but they're here to make the pattern irrefutable
         &BeaconState::Base(_) | &BeaconState::Altair(_) => None,

beacon_node/beacon_chain/src/lib.rs

@@ -7,6 +7,7 @@ mod beacon_chain;
 mod beacon_fork_choice_store;
 pub mod beacon_proposer_cache;
 mod beacon_snapshot;
+pub mod blob_verification;
 pub mod block_reward;
 mod block_times_cache;
 mod block_verification;

beacon_node/beacon_chain/src/metrics.rs

@@ -972,6 +972,22 @@ lazy_static! {
             "beacon_pre_finalization_block_lookup_count",
             "Number of block roots subject to single block lookups"
         );
+
+    /*
+     * Blob sidecar Verification
+     */
+    pub static ref BLOBS_SIDECAR_PROCESSING_REQUESTS: Result<IntCounter> = try_create_int_counter(
+        "beacon_blobs_sidecar_processing_requests_total",
+        "Count of all blob sidecars submitted for processing"
+    );
+    pub static ref BLOBS_SIDECAR_PROCESSING_SUCCESSES: Result<IntCounter> = try_create_int_counter(
+        "beacon_blobs_sidecar_processing_successes_total",
+        "Number of blob sidecars verified for gossip"
+    );
+    pub static ref BLOBS_SIDECAR_GOSSIP_VERIFICATION_TIMES: Result<Histogram> = try_create_histogram(
+        "beacon_blobs_sidecar_gossip_verification_seconds",
+        "Full runtime of blob sidecars gossip verification"
+    );
 }
 
 // Fifth lazy-static block is used to account for macro recursion limit.

beacon_node/beacon_chain/src/test_utils.rs

@@ -420,6 +420,10 @@ where
             spec.capella_fork_epoch.map(|epoch| {
                 genesis_time + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
             });
+        mock.server.execution_block_generator().eip4844_time =
+            spec.eip4844_fork_epoch.map(|epoch| {
+                genesis_time + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
+            });
 
         self
     }
@@ -429,10 +433,14 @@ where
         let shanghai_time = spec.capella_fork_epoch.map(|epoch| {
             HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
         });
+        let eip4844_time = spec.eip4844_fork_epoch.map(|epoch| {
+            HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
+        });
         let mock = MockExecutionLayer::new(
             self.runtime.task_executor.clone(),
             DEFAULT_TERMINAL_BLOCK,
             shanghai_time,
+            eip4844_time,
             None,
             Some(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap()),
             spec,
@@ -456,10 +464,14 @@ where
         let shanghai_time = spec.capella_fork_epoch.map(|epoch| {
             HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
         });
+        let eip4844_time = spec.eip4844_fork_epoch.map(|epoch| {
+            HARNESS_GENESIS_TIME + spec.seconds_per_slot * E::slots_per_epoch() * epoch.as_u64()
+        });
         let mock_el = MockExecutionLayer::new(
             self.runtime.task_executor.clone(),
             DEFAULT_TERMINAL_BLOCK,
             shanghai_time,
+            eip4844_time,
             builder_threshold,
             Some(JwtKey::from_slice(&DEFAULT_JWT_SECRET).unwrap()),
             spec.clone(),