Method build

crates/consensus/engine/src/task_queue/core.rs:86–128

Starts a block build directly against the execution layer.

(
        &mut self,
        client: Arc<EngineClient_>,
        config: Arc<RollupConfig>,
        attributes: AttributesWithParent,
    )

    /// Starts a block build directly against the execution layer.
    pub async fn build(
        &mut self,
        client: Arc<EngineClient_>,
        config: Arc<RollupConfig>,
        attributes: AttributesWithParent,
    ) -> Result<PayloadId, BuildTaskError> {
        let _task_timer =
            base_metrics::timed!(Metrics::engine_task_duration(Metrics::BUILD_TASK_LABEL));

        match Self::build_with_state(&self.state, client.as_ref(), config.as_ref(), attributes)
            .await
        {
            Ok(payload_id) => {
                Metrics::engine_task_count(Metrics::BUILD_TASK_LABEL).increment(1);
                Ok(payload_id)
            }
            Err(err) => {
                let severity = err.severity();
                Metrics::engine_task_failure(Metrics::BUILD_TASK_LABEL, severity.as_label())
                    .increment(1);

                match severity {
                    EngineTaskErrorSeverity::Temporary => {
                        trace!(target: "engine", error = %err, "Temporary engine error");
                    }
                    EngineTaskErrorSeverity::Deferred => {
                        trace!(target: "engine", error = %err, "Deferred engine error");
                    }
                    EngineTaskErrorSeverity::Critical => {
                        error!(target: "engine", error = %err, "Critical engine error");
                    }
                    EngineTaskErrorSeverity::Reset => {
                        warn!(target: "engine", "Engine requested derivation reset");
                    }
                    EngineTaskErrorSeverity::Flush => {
                        warn!(target: "engine", "Engine requested derivation flush");
                    }
                }

                Err(err)
            }
        }
    }

    /// Starts a block build using the provided engine state.
    pub async fn build_with_state(