chore: clean up get payload

Author: varun-doshi

src/server.rs

@@ -603,80 +603,72 @@ impl RollupBoostServer {
         payload_id: PayloadId,
         version: Version,
     ) -> RpcResult<OpExecutionPayloadEnvelope> {
-        let execution_mode = self.execution_mode();
-        let l2_client_future = self.l2_client.get_payload(payload_id, version);
+        let l2_fut = self.l2_client.get_payload(payload_id, version);
 
-        // if mode is `disabled` dont await the builder payload
-        let (payload, context) = if execution_mode.is_disabled() {
-            let result = match l2_client_future.await {
+        // If execution mode is disabled, return the l2 payload without sending
+        // the request to the builder
+        if self.execution_mode().is_disabled() {
+            return match l2_fut.await {
                 Ok(payload) => {
                     self.probes.set_health(Health::Healthy);
-                    Ok((payload, PayloadSource::L2))
-                }
-                Err(e) => {
-                    self.probes.set_health(Health::ServiceUnavailable);
-                    Err(e)
+                    tracing::Span::current().record("payload_source", "L2");
+                    counter!("rpc.blocks_created", "source" => "L2").increment(1);
+
+                    let execution_payload = ExecutionPayload::from(payload.clone());
+                    info!(
+                        message = "returning block",
+                        "hash" = %execution_payload.block_hash(),
+                        "number" = %execution_payload.block_number(),
+                        context = "L2",
+                        %payload_id,
+                    );
+
+                    Ok(payload)
                 }
+
+                Err(e) => Err(e.into()),
             };
-            result
-        } else {
-            // if mode is `enabled` or `dry_run` await the builder + L2 payload
-            let builder_client_future = Box::pin(async move {
-                if let Some(cause) = self.payload_trace_context.trace_id(&payload_id) {
-                    tracing::Span::current().follows_from(cause);
-                }
+        }
 
-                if !self.payload_trace_context.has_builder_payload(&payload_id) {
-                    // block builder won't build a block without attributes
-                    info!(message = "builder has no payload, skipping get_payload call to builder");
-                    return RpcResult::Ok(None);
-                }
+        // Forward the get payload request to the builder
+        let builder_fut = async {
+            if let Some(cause) = self.payload_trace_context.trace_id(&payload_id) {
+                tracing::Span::current().follows_from(cause);
+            }
+            if !self.payload_trace_context.has_builder_payload(&payload_id) {
+                info!(message = "builder has no payload, skipping get_payload call to builder");
+                return RpcResult::Ok(None);
+            }
 
-                let builder = self.builder_client.clone();
-                let payload = builder.get_payload(payload_id, version).await?;
+            // Get payload and validate with the local l2 client
+            let payload = self.builder_client.get_payload(payload_id, version).await?;
+            let _ = self
+                .l2_client
+                .new_payload(NewPayload::from(payload.clone()))
+                .await?;
 
-                // Send the payload to the local execution engine with engine_newPayload to validate the block from the builder.
-                // Otherwise, we do not want to risk the network to a halt since op-node will not be able to propose the block.
-                // If validation fails, return the local block since that one has already been validated.
-                let _ = self
-                    .l2_client
-                    .new_payload(NewPayload::from(payload.clone()))
-                    .await?;
+            Ok(Some(payload))
+        };
 
-                Ok(Some(payload))
-            });
+        let (l2_payload, builder_payload) = tokio::join!(l2_fut, builder_fut);
 
-            let (l2_payload, builder_payload) =
-                tokio::join!(l2_client_future, builder_client_future);
-            let result = match (builder_payload, l2_payload, execution_mode.is_dry_run()) {
-                (Ok(Some(_)), Ok(l2), true) => {
-                    // if builder and l2 is okay and `is_dry_run`, then always return L2 payload with signal `Healthy`
-                    self.probes.set_health(Health::Healthy);
-                    Ok((l2, PayloadSource::L2))
-                }
-                (_, Ok(l2), true) => {
-                    // if builder has failed/errored and l2 is okay and `is_dry_run`, then always return L2 payload, but signal `PartialContent`
-                    self.probes.set_health(Health::PartialContent);
-                    Ok((l2, PayloadSource::L2))
-                }
-                (Ok(Some(builder)), Ok(_), false) => {
-                    // if builder and L2 is okay and `is_dry_run` is false, then always return builder payload i.e. `Enabled` Mode with signal `Healthy`
-                    self.probes.set_health(Health::Healthy);
-                    Ok((builder, PayloadSource::Builder))
-                }
-                (_, Ok(l2), false) => {
-                    // builder failed to return/errored and `l2_payload` is ok and `is_dry_run` is false, then always return L2 payload with signal `PartialContent`
-                    self.probes.set_health(Health::PartialContent);
-                    Ok((l2, PayloadSource::L2))
-                }
-                (_, Err(e), _) => {
-                    // l2 failed to return a payload
-                    self.probes.set_health(Health::ServiceUnavailable);
-                    Err(e)
+        // Evaluate the builder and l2 response and select the final payload
+        let (payload, context) = {
+            let l2_payload =
+                l2_payload.inspect_err(|_| self.probes.set_health(Health::ServiceUnavailable))?;
+            self.probes.set_health(Health::Healthy);
+
+            if let Ok(Some(payload)) = builder_payload {
+                if self.execution_mode().is_dry_run() {
+                    (l2_payload, PayloadSource::L2)
+                } else {
+                    (payload, PayloadSource::Builder)
                 }
-            };
-            result
-        }?;
+            } else {
+                self.probes.set_health(Health::PartialContent);
+                (l2_payload, PayloadSource::L2)
+            }
+        };
 
         tracing::Span::current().record("payload_source", context.to_string());
         // To maintain backwards compatibility with old metrics, we need to record blocks built