Fixed a ton of state_processing stuff (#3642)

FIXME's:
 * consensus/fork_choice/src/fork_choice.rs
 * consensus/state_processing/src/per_epoch_processing/capella.rs
 * consensus/types/src/execution_payload_header.rs
 
TODO's:
 * consensus/state_processing/src/per_epoch_processing/capella/partial_withdrawals.rs
 * consensus/state_processing/src/per_epoch_processing/capella/full_withdrawals.rs

consensus/types/src/beacon_state.rs

@@ -718,6 +718,23 @@ impl<T: EthSpec> BeaconState<T> {
         }
     }
 
+    pub fn latest_execution_payload_header_mut(
+        &mut self,
+    ) -> Result<ExecutionPayloadHeaderRefMut<T>, Error> {
+        match self {
+            BeaconState::Base(_) | BeaconState::Altair(_) => Err(Error::IncorrectStateVariant),
+            BeaconState::Merge(state) => Ok(ExecutionPayloadHeaderRefMut::Merge(
+                &mut state.latest_execution_payload_header,
+            )),
+            BeaconState::Capella(state) => Ok(ExecutionPayloadHeaderRefMut::Capella(
+                &mut state.latest_execution_payload_header,
+            )),
+            BeaconState::Eip4844(state) => Ok(ExecutionPayloadHeaderRefMut::Eip4844(
+                &mut state.latest_execution_payload_header,
+            )),
+        }
+    }
+
     /// Return `true` if the validator who produced `slot_signature` is eligible to aggregate.
     ///
     /// Spec v0.12.1

consensus/types/src/execution_payload_header.rs

@@ -65,6 +65,73 @@ pub struct ExecutionPayloadHeader<T: EthSpec> {
     pub withdrawals_root: Hash256,
 }
 
+impl<'a, T: EthSpec> ExecutionPayloadHeaderRef<'a, T> {
+    // FIXME: maybe this could be a derived trait..
+    pub fn is_default(self) -> bool {
+        match self {
+            ExecutionPayloadHeaderRef::Merge(header) => {
+                *header == ExecutionPayloadHeaderMerge::default()
+            }
+            ExecutionPayloadHeaderRef::Capella(header) => {
+                *header == ExecutionPayloadHeaderCapella::default()
+            }
+            ExecutionPayloadHeaderRef::Eip4844(header) => {
+                *header == ExecutionPayloadHeaderEip4844::default()
+            }
+        }
+    }
+}
+
+impl<T: EthSpec> ExecutionPayloadHeaderMerge<T> {
+    pub fn upgrade_to_capella(&self) -> ExecutionPayloadHeaderCapella<T> {
+        // TODO: if this is correct we should calculate and hardcode this..
+        let empty_withdrawals_root =
+            VariableList::<Withdrawal, T::MaxWithdrawalsPerPayload>::empty().tree_hash_root();
+        ExecutionPayloadHeaderCapella {
+            parent_hash: self.parent_hash,
+            fee_recipient: self.fee_recipient,
+            state_root: self.state_root,
+            receipts_root: self.receipts_root,
+            logs_bloom: self.logs_bloom.clone(),
+            prev_randao: self.prev_randao,
+            block_number: self.block_number,
+            gas_limit: self.gas_limit,
+            gas_used: self.gas_used,
+            timestamp: self.timestamp,
+            extra_data: self.extra_data.clone(),
+            base_fee_per_gas: self.base_fee_per_gas,
+            block_hash: self.block_hash,
+            transactions_root: self.transactions_root,
+            // FIXME: the spec doesn't seem to define what to do here..
+            withdrawals_root: empty_withdrawals_root,
+        }
+    }
+}
+
+impl<T: EthSpec> ExecutionPayloadHeaderCapella<T> {
+    pub fn upgrade_to_eip4844(&self) -> ExecutionPayloadHeaderEip4844<T> {
+        ExecutionPayloadHeaderEip4844 {
+            parent_hash: self.parent_hash,
+            fee_recipient: self.fee_recipient,
+            state_root: self.state_root,
+            receipts_root: self.receipts_root,
+            logs_bloom: self.logs_bloom.clone(),
+            prev_randao: self.prev_randao,
+            block_number: self.block_number,
+            gas_limit: self.gas_limit,
+            gas_used: self.gas_used,
+            timestamp: self.timestamp,
+            extra_data: self.extra_data.clone(),
+            base_fee_per_gas: self.base_fee_per_gas,
+            // TODO: verify if this is correct
+            excess_blobs: 0,
+            block_hash: self.block_hash,
+            transactions_root: self.transactions_root,
+            withdrawals_root: self.withdrawals_root,
+        }
+    }
+}
+
 impl<T: EthSpec> From<ExecutionPayloadMerge<T>> for ExecutionPayloadHeaderMerge<T> {
     fn from(payload: ExecutionPayloadMerge<T>) -> Self {
         Self {

consensus/types/src/payload.rs

@@ -621,17 +621,6 @@ impl<T: EthSpec> ExecPayload<T> for BlindedPayload<T> {
     // TODO: can this function be optimized?
     fn is_default(&self) -> bool {
         match self {
-            /*
-            Self::Merge(payload) => {
-                payload.execution_payload_header == ExecutionPayloadHeaderMerge::default()
-            }
-            Self::Capella(payload) => {
-                payload.execution_payload_header == ExecutionPayloadHeaderCapella::default()
-            }
-            Self::Eip4844(payload) => {
-                payload.execution_payload_header == ExecutionPayloadHeaderEip4844::default()
-            }
-            */
             Self::Merge(payload) => payload.is_default(),
             Self::Capella(payload) => payload.is_default(),
             Self::Eip4844(payload) => payload.is_default(),