Function execute_block

finalizer/src/actor.rs:1314–1461

Core execution logic that applies a block's state transitions to any ConsensusState. This method: - Calls check_payload on the engine client (validates and optimistically executes the block on the EVM) - Applies consensus-layer state transitions (deposits, withdrawals, validators) - Updates the forkchoice head - Creates checkpoints at epoch boundaries This does NOT handle epoch transitions (acti

(
    engine_client: &mut C,
    context: &ContextCell<R>,
    block: &Block,
    state: &mut ConsensusState,
    consts: &ProtocolConsts,
    protocol_version_digest: Digest,
)

                Ok(stake_changed) => stake_changed,
                Err(e) => {
                    warn!("skipping invalid protocol parameter changes at epoch boundary: {e}");
                    false
                }
            };

            // Build the committee for the next epoch.
            self.validator_exit = self.update_validator_committee(stake_changed);

            // Reschedule any overflow withdrawals that exceeded the per-epoch
            // total withdrawal cap to the next epoch.
            let current_epoch = self.canonical_state.get_epoch();
            if self
                .canonical_state
                .get_withdrawal_count_for_epoch(current_epoch)
                > 0
            {
                let overflow_count = self
                    .canonical_state
                    .get_withdrawal_count_for_epoch(current_epoch);
                info!(
                    current_epoch,
                    overflow_count, "rescheduling overflow withdrawals to next epoch"
                );
                self.canonical_state
                    .reschedule_withdrawal_epoch(current_epoch, current_epoch + 1);
            }

            #[cfg(feature = "prom")]
            let db_operations_start = Instant::now();
            // This pending checkpoint should always exist, because it was created at the previous height.
            // The only case where the pending checkpoint doesn't exist here is if the node checkpointed.
            // The checkpoint is created at the penultimate block of the epoch, and finalized at the last
            // block. So if a node checkpoints, it will start at the height of the penultimate block.
            if let Some(checkpoint) = &self.canonical_state.take_pending_checkpoint() {
                debug!(
                    epoch = self.canonical_state.get_epoch(),
                    checkpoint_digest = ?checkpoint.digest,
                    "storing finalized checkpoint to database"
                );
                #[cfg(feature = "prom")]
                let checkpoint_start = Instant::now();
                self.db
                    .store_finalized_checkpoint(
                        self.canonical_state.get_epoch(),
                        checkpoint,
                        block.clone(),
                    )
                    .await?;
                #[cfg(feature = "prom")]
                {
                    let checkpoint_duration = checkpoint_start.elapsed().as_micros() as f64;
                    histogram!("finalizer_db_checkpoint_write_micros").record(checkpoint_duration);
                }
            }

            // Increment epoch
            let next_epoch = self.canonical_state.get_epoch() + 1;
            self.canonical_state.set_epoch(next_epoch);