fix(core,host,sgx): fix compiler and clippy errors

core/src/lib.rs

@@ -333,7 +333,7 @@ mod tests {
             l1_network,
             proof_type,
             blob_proof_type: BlobProofType::ProofOfEquivalence,
-            prover_args: test_proof_params(),
+            prover_args: test_proof_params(false),
         };
         prove_block(l1_chain_spec, taiko_chain_spec, proof_request).await;
     }
@@ -456,6 +456,7 @@ mod tests {
 
         let proof_request = ProofRequest {
             block_number,
+            l1_inclusion_block_number: 0,
             network,
             graffiti: B256::ZERO,
             prover: Address::ZERO,

core/src/prover.rs

@@ -58,6 +58,7 @@ impl Prover for NativeProver {
         }
 
         Ok(Proof {
+            input: None,
             proof: None,
             quote: None,
         })
@@ -68,10 +69,10 @@ impl Prover for NativeProver {
     }
 
     async fn aggregate(
-        input: raiko_lib::input::AggregationGuestInput,
-        output: &raiko_lib::input::AggregationGuestOutput,
-        config: &ProverConfig,
-        store: Option<&mut dyn IdWrite>,
+        _input: raiko_lib::input::AggregationGuestInput,
+        _output: &raiko_lib::input::AggregationGuestOutput,
+        _config: &ProverConfig,
+        _store: Option<&mut dyn IdWrite>,
     ) -> ProverResult<Proof> {
         Ok(Proof {
             ..Default::default()

host/src/server/api/v3/proof/cancel.rs

@@ -4,7 +4,6 @@ use raiko_core::{
     provider::get_task_data,
 };
 use raiko_tasks::{TaskDescriptor, TaskManager, TaskStatus};
-use serde_json::Value;
 use utoipa::OpenApi;
 
 use crate::{interfaces::HostResult, server::api::v2::CancelStatus, Message, ProverState};
@@ -27,11 +26,11 @@ use crate::{interfaces::HostResult, server::api::v2::CancelStatus, Message, Prov
 /// - risc0 - uses the risc0 prover
 async fn cancel_handler(
     State(prover_state): State<ProverState>,
-    Json(aggregation_request): Json<AggregationRequest>,
+    Json(mut aggregation_request): Json<AggregationRequest>,
 ) -> HostResult<CancelStatus> {
     // Override the existing proof request config from the config file and command line
     // options with the request from the client.
-    aggregation_request.merge(&prover_state.request_config());
+    aggregation_request.merge(&prover_state.request_config())?;
 
     let proof_request_opts: Vec<ProofRequestOpt> = aggregation_request.into();
 

host/src/server/api/v3/proof/mod.rs

@@ -1,5 +1,6 @@
 use std::str::FromStr;
 
+use anyhow::anyhow;
 use axum::{debug_handler, extract::State, routing::post, Json, Router};
 use raiko_core::{
     interfaces::{AggregationRequest, ProofRequest, ProofRequestOpt, ProofType},
@@ -8,13 +9,12 @@ use raiko_core::{
 use raiko_lib::input::{AggregationGuestInput, AggregationGuestOutput};
 use raiko_tasks::{TaskDescriptor, TaskManager, TaskStatus};
 use reth_primitives::B256;
-use serde_json::Value;
 use utoipa::OpenApi;
 
 use crate::{
     interfaces::HostResult,
     metrics::{inc_current_req, inc_guest_req_count, inc_host_req_count},
-    server::api::v2::{self, Status},
+    server::api::{v2, v3::Status},
     Message, ProverState,
 };
 
@@ -38,16 +38,16 @@ mod cancel;
 /// - risc0 - uses the risc0 prover
 async fn proof_handler(
     State(prover_state): State<ProverState>,
-    Json(aggregation_request): Json<AggregationRequest>,
+    Json(mut aggregation_request): Json<AggregationRequest>,
 ) -> HostResult<Status> {
     inc_current_req();
     // Override the existing proof request config from the config file and command line
     // options with the request from the client.
-    aggregation_request.merge(&prover_state.request_config());
+    aggregation_request.merge(&prover_state.request_config())?;
 
     let mut tasks = Vec::with_capacity(aggregation_request.block_numbers.len());
 
-    let proof_request_opts: Vec<ProofRequestOpt> = aggregation_request.into();
+    let proof_request_opts: Vec<ProofRequestOpt> = aggregation_request.clone().into();
 
     // Construct the actual proof request from the available configs.
     for proof_request_opt in proof_request_opts {
@@ -78,19 +78,16 @@ async fn proof_handler(
     let mut is_registered = false;
     let mut is_success = true;
 
-    let mut statuses = Vec::with_capacity(tasks.len());
-
-    for task in tasks {
-        let status = manager.get_task_proving_status(&task).await?;
+    for task in tasks.iter() {
+        let status = manager.get_task_proving_status(task).await?;
 
         let Some((latest_status, ..)) = status.last() else {
             // If there are no tasks with provided config, create a new one.
-            manager.enqueue_task(&task).await?;
+            manager.enqueue_task(task).await?;
 
-            prover_state
-                .task_channel
-                .try_send(Message::from(&aggregation_request))?;
+            prover_state.task_channel.try_send(Message::from(task))?;
             is_registered = true;
+            continue;
         };
 
         match latest_status {
@@ -100,21 +97,18 @@ async fn proof_handler(
             | TaskStatus::Cancelled_NeverStarted
             | TaskStatus::CancellationInProgress => {
                 manager
-                    .update_task_progress(task, TaskStatus::Registered, None)
+                    .update_task_progress(task.clone(), TaskStatus::Registered, None)
                     .await?;
 
-                prover_state
-                    .task_channel
-                    .try_send(Message::from(&aggregation_request))?;
+                prover_state.task_channel.try_send(Message::from(task))?;
 
                 is_registered = true;
+                is_success = false;
             }
             // If the task has succeeded, return the proof.
-            TaskStatus::Success => {
-                is_success = is_success && true;
-            }
+            TaskStatus::Success => {}
             // For all other statuses just return the status.
-            status => Ok((*status).into()),
+            _status => {}
         }
     }
 
@@ -129,13 +123,18 @@ async fn proof_handler(
             proofs.push(proof);
         }
 
-        let proof_type = ProofType::from_str(aggregation_request.proof_type)?;
+        let proof_type = ProofType::from_str(
+            aggregation_request
+                .proof_type
+                .as_ref()
+                .ok_or_else(|| anyhow!("No proof type"))?,
+        )?;
         let input = AggregationGuestInput { proofs };
         let output = AggregationGuestOutput { hash: B256::ZERO };
         let config = serde_json::to_value(aggregation_request)?;
 
         let proof = proof_type
-            .aggregate_proofs(input, &output, &config, manager)
+            .aggregate_proofs(input, &output, &config, Some(&mut manager))
             .await?;
 
         Ok(proof.into())

provers/sgx/guest/src/one_shot.rs

@@ -10,9 +10,9 @@ use base64_serde::base64_serde_type;
 use raiko_lib::{
     builder::calculate_block_header,
     consts::VerifierType,
-    input::{AggregationGuestInput, GuestInput, RawAggregationGuestInput},
+    input::{GuestInput, RawAggregationGuestInput},
     primitives::{keccak, Address, B256},
-    protocol_instance::{aggregation_output, aggregation_output_combine, ProtocolInstance},
+    protocol_instance::{aggregation_output_combine, ProtocolInstance},
 };
 use secp256k1::{Keypair, SecretKey};
 use serde::Serialize;
@@ -208,8 +208,8 @@ pub async fn aggregate(global_opts: GlobalOpts, args: OneShotArgs) -> Result<()>
     let aggregation_hash = keccak::keccak(aggregation_output_combine(
         [
             vec![
-                B256::left_padding_from(&old_instance.to_vec()),
-                B256::left_padding_from(&new_instance.to_vec()),
+                B256::left_padding_from(old_instance.as_ref()),
+                B256::left_padding_from(new_instance.as_ref()),
             ],
             input
                 .proofs

provers/sgx/prover/src/lib.rs

@@ -155,9 +155,9 @@ impl Prover for SgxProver {
 
     async fn aggregate(
         input: AggregationGuestInput,
-        output: &AggregationGuestOutput,
+        _output: &AggregationGuestOutput,
         config: &ProverConfig,
-        id_store: Option<&mut dyn IdWrite>,
+        _id_store: Option<&mut dyn IdWrite>,
     ) -> ProverResult<Proof> {
         let sgx_param = SgxParam::deserialize(config.get("sgx").unwrap()).unwrap();