Function process_execution_requests

finalizer/src/actor.rs:1719–1919

(
    #[allow(unused)] context: &ContextCell<R>,
    block: &Block,
    new_height: u64,
    state: &mut ConsensusState,
    consts: &ProtocolConsts,
)

                    }
                    outcome = HandleOutcome::Buffered(());
                    // The next block in `to_process` will be processed.
                    // Potential orphaned children of the current block won't
                    // be added to `to_process`, since the current block has to be
                    // executed before them.
                    continue;
                }
                ExecuteOutcome::InvalidPayload => {
                    warn!(
                        height,
                        ?block_digest,
                        "discarding notarized block with invalid payload"
                    );
                    #[cfg(feature = "prom")]
                    counter!("notarized_block_invalid_total").increment(1);
                    continue;
                }
            }

            // Store the new fork state
            self.fork_states.entry(height).or_default().insert(
                block_digest,
                ForkState {
                    block_digest,
                    parent_digest,
                    consensus_state: fork_state.clone(),
                },
            );

            // The fork forkchoice was already committed to reth (and its status
            // gated) inside `execute_block`, so validators can build/verify on it.

            let total_fork_count: usize = self.fork_states.values().map(|f| f.len()).sum();
            info!(
                height,
                view = block.view(),
                ?block_digest,
                "executed notarized block into fork"
            );
            trace!(
                height,
                total_fork_states = total_fork_count,
                heights_tracked = self.fork_states.len(),
                "fork state summary"
            );
            self.height_notify_executed(height, block_digest);

            // Add orphaned children to the processing queue
            if let Some(children) = self
                .orphaned_blocks
                .get(&(height + 1))
                .and_then(|children_map| children_map.get(&block_digest))
            {
                debug!(
                    height,
                    num_children = children.len(),
                    "queueing orphaned children"
                );
                to_process.extend(children.clone());