Function parse_execution_requests

finalizer/src/actor.rs:1463–1717

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

                .get_active_or_joining_validators()
                .iter()
                .map(|(node_key, _)| node_key.clone())
                .collect();
            let joining_node_keys: Vec<_> = active_or_joining_node_keys
                .iter()
                .filter(|key| !active_node_keys.contains(key))
                .cloned()
                .collect();
            let observer_keys = derive_observer_keys(
                &active_or_joining_node_keys,
                &self.observer_domain,
                self.canonical_state.get_observers_per_validator(),
            );
            let secondary_keys: Vec<_> =
                joining_node_keys.into_iter().chain(observer_keys).collect();
            self.oracle
                .track(
                    self.canonical_state.get_epoch(),
                    active_node_keys,
                    secondary_keys,
                )
                .await;

            // Send the new validator list to the orchestrator and start the Simplex engine
            // for the new epoch
            let active_validators = self.canonical_state.get_active_validators();
            debug!(
                epoch = self.canonical_state.get_epoch(),
                num_active_validators = active_validators.len(),
                "signaling orchestrator to enter new epoch"
            );

            orchestrator_mailbox
                .report(Message::Enter(EpochTransition {
                    epoch: Epoch::new(self.canonical_state.get_epoch()),
                    validator_keys: active_validators,
                }))
                .await;
            epoch_change = true;
        } else {
            // Every block needs to be ack'ed.
            // On the last block of an epoch we send the ack before updating the oracle and
            // reporting to the orchestrator, because those calls might be blocking.
            ack_tx.acknowledge();
        }

        info!(new_height, epoch = current_epoch, "executed block");

        if epoch_change {
            // Shut down the Simplex engine for the old epoch
            debug!(
                old_epoch = self.canonical_state.get_epoch() - 1,
                "signaling orchestrator to exit old epoch"
            );
            orchestrator_mailbox
                .report(Message::Exit(Epoch::new(
                    self.canonical_state.get_epoch() - 1,
                )))
                .await;