feat(proof-data-handler): return 204 HTTP status code if no proofs are available

core/lib/dal/src/tee_proof_generation_dal.rs

@@ -196,38 +196,6 @@ impl TeeProofGenerationDal<'_, '_> {
         Ok(())
     }
 
-    pub async fn insert_tee_proof_generation_job(
-        &mut self,
-        batch_number: L1BatchNumber,
-        tee_type: TeeType,
-    ) -> DalResult<()> {
-        let batch_number = i64::from(batch_number.0);
-        let query = sqlx::query!(
-            r#"
-            INSERT INTO
-            tee_proof_generation_details (
-                l1_batch_number, tee_type, status, created_at, updated_at
-            )
-            VALUES
-            ($1, $2, $3, NOW(), NOW())
-            ON CONFLICT (l1_batch_number, tee_type) DO NOTHING
-            "#,
-            batch_number,
-            tee_type.to_string(),
-            TeeProofGenerationJobStatus::Unpicked.to_string(),
-        );
-        let instrumentation = Instrumented::new("insert_tee_proof_generation_job")
-            .with_arg("l1_batch_number", &batch_number)
-            .with_arg("tee_type", &tee_type);
-        instrumentation
-            .clone()
-            .with(query)
-            .execute(self.storage)
-            .await?;
-
-        Ok(())
-    }
-
     pub async fn save_attestation(&mut self, pubkey: &[u8], attestation: &[u8]) -> DalResult<()> {
         let query = sqlx::query!(
             r#"
@@ -291,6 +259,40 @@ impl TeeProofGenerationDal<'_, '_> {
         Ok(proofs)
     }
 
+    /// For testing purposes only.
+    pub async fn insert_tee_proof_generation_job(
+        &mut self,
+        batch_number: L1BatchNumber,
+        tee_type: TeeType,
+    ) -> DalResult<()> {
+        let batch_number = i64::from(batch_number.0);
+        let query = sqlx::query!(
+            r#"
+            INSERT INTO
+            tee_proof_generation_details (
+                l1_batch_number, tee_type, status, created_at, updated_at
+            )
+            VALUES
+            ($1, $2, $3, NOW(), NOW())
+            ON CONFLICT (l1_batch_number, tee_type) DO NOTHING
+            "#,
+            batch_number,
+            tee_type.to_string(),
+            TeeProofGenerationJobStatus::Unpicked.to_string(),
+        );
+        let instrumentation = Instrumented::new("insert_tee_proof_generation_job")
+            .with_arg("l1_batch_number", &batch_number)
+            .with_arg("tee_type", &tee_type);
+        instrumentation
+            .clone()
+            .with(query)
+            .execute(self.storage)
+            .await?;
+
+        Ok(())
+    }
+
+    /// For testing purposes only.
     pub async fn get_oldest_unpicked_batch(&mut self) -> DalResult<Option<L1BatchNumber>> {
         let query = sqlx::query!(
             r#"

core/node/proof_data_handler/src/lib.rs

@@ -1,7 +1,7 @@
 use std::{net::SocketAddr, sync::Arc};
 
 use anyhow::Context as _;
-use axum::{extract::Path, routing::post, Json, Router};
+use axum::{extract::Path, http::StatusCode, response::IntoResponse, routing::post, Json, Router};
 use request_processor::RequestProcessor;
 use tee_request_processor::TeeRequestProcessor;
 use tokio::sync::watch;
@@ -10,7 +10,7 @@ use zksync_dal::{ConnectionPool, Core};
 use zksync_object_store::ObjectStore;
 use zksync_prover_interface::api::{
     ProofGenerationDataRequest, RegisterTeeAttestationRequest, SubmitProofRequest,
-    SubmitTeeProofRequest, TeeProofGenerationDataRequest,
+    SubmitTeeProofRequest, TeeProofGenerationDataRequest, TeeProofGenerationDataResponse,
 };
 use zksync_types::commitment::L1BatchCommitmentMode;
 
@@ -96,9 +96,15 @@ fn create_proof_processing_router(
             "/tee/proof_inputs",
             post(
                 move |payload: Json<TeeProofGenerationDataRequest>| async move {
-                    get_tee_proof_gen_processor
+                    let result: Result<Json<zksync_prover_interface::api::TeeProofGenerationDataResponse>, errors::RequestProcessorError> = get_tee_proof_gen_processor
                         .get_proof_generation_data(payload)
-                        .await
+                        .await;
+
+                    match result {
+                        Ok(Json(TeeProofGenerationDataResponse(None))) => (StatusCode::NO_CONTENT, Json("No new TeeVerifierInputs are available yet")).into_response(),
+                        Ok(data) => (StatusCode::OK, data).into_response(),
+                        Err(e) => e.into_response(),
+                    }
                 },
             ),
         )

core/node/proof_data_handler/src/tee_request_processor.rs

@@ -60,7 +60,9 @@ impl TeeRequestProcessor {
                 .tee_verifier_input_for_existing_batch(l1_batch_number)
                 .await
             {
-                Ok(input) => break Ok(Json(TeeProofGenerationDataResponse(Some(Box::new(input))))),
+                Ok(input) => {
+                    break Ok(Json(TeeProofGenerationDataResponse(Some(Box::new(input)))));
+                }
                 Err(RequestProcessorError::ObjectStore(ObjectStoreError::KeyNotFound(_))) => {
                     missing_range = match missing_range {
                         Some((start, _)) => Some((start, l1_batch_number)),

core/node/proof_data_handler/src/tests.rs

@@ -16,14 +16,11 @@ use crate::create_proof_processing_router;
 
 #[tokio::test]
 async fn request_tee_proof_inputs() {
-    let batch_number = L1BatchNumber::from(1);
     let db_conn_pool = ConnectionPool::test_pool().await;
 
-    mock_tee_batch_status(db_conn_pool.clone(), batch_number).await;
-
     let app = create_proof_processing_router(
         MockObjectStore::arc(),
-        db_conn_pool,
+        db_conn_pool.clone(),
         ProofDataHandlerConfig {
             http_port: 1337,
             proof_generation_timeout_in_secs: 10,
@@ -32,7 +29,7 @@ async fn request_tee_proof_inputs() {
         L1BatchCommitmentMode::Rollup,
     );
     let test_cases = vec![
-        (json!({ "tee_type": "sgx" }), StatusCode::OK),
+        (json!({ "tee_type": "sgx" }), StatusCode::NO_CONTENT),
         (
             json!({ "tee_type": "Sgx" }),
             StatusCode::UNPROCESSABLE_ENTITY,