feat(host,tasks): complete aggregation api

core/src/interfaces.rs

@@ -154,6 +154,17 @@ impl TryFrom<u8> for ProofType {
     }
 }
 
+impl From<ProofType> for u8 {
+    fn from(val: ProofType) -> Self {
+        match val {
+            ProofType::Native => 0,
+            ProofType::Sp1 => 1,
+            ProofType::Sgx => 2,
+            ProofType::Risc0 => 3,
+        }
+    }
+}
+
 impl From<ProofType> for VerifierType {
     fn from(val: ProofType) -> Self {
         match val {

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

@@ -0,0 +1,75 @@
+use std::str::FromStr;
+
+use axum::{debug_handler, extract::State, routing::post, Json, Router};
+use raiko_core::interfaces::{AggregationOnlyRequest, ProofType};
+use raiko_tasks::{TaskManager, TaskStatus};
+use utoipa::OpenApi;
+
+use crate::{
+    interfaces::HostResult,
+    metrics::{inc_guest_req_count, inc_host_req_count},
+    server::api::v2::CancelStatus,
+    Message, ProverState,
+};
+
+#[utoipa::path(post, path = "/proof/aggregate/cancel",
+    tag = "Proving",
+    request_body = AggregationOnlyRequest,
+    responses (
+        (status = 200, description = "Successfully cancelled proof aggregation task", body = CancelStatus)
+    )
+)]
+#[debug_handler(state = ProverState)]
+/// Cancel a proof aggregation task with requested config.
+///
+/// Accepts a proof aggregation request and cancels a proving task with the specified guest prover.
+/// The guest provers currently available are:
+/// - native - constructs a block and checks for equality
+/// - sgx - uses the sgx environment to construct a block and produce proof of execution
+/// - sp1 - uses the sp1 prover
+/// - risc0 - uses the risc0 prover
+async fn cancel_handler(
+    State(prover_state): State<ProverState>,
+    Json(mut aggregation_request): Json<AggregationOnlyRequest>,
+) -> 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())?;
+
+    let proof_type = ProofType::from_str(
+        aggregation_request
+            .proof_type
+            .as_deref()
+            .unwrap_or_default(),
+    )?;
+    inc_host_req_count(0);
+    inc_guest_req_count(&proof_type, 0);
+
+    if aggregation_request.proofs.is_empty() {
+        return Err(anyhow::anyhow!("No proofs provided").into());
+    }
+
+    prover_state
+        .task_channel
+        .try_send(Message::CancelAggregate(aggregation_request.clone()))?;
+
+    let mut manager = prover_state.task_manager();
+
+    manager
+        .update_aggregation_task_progress(&aggregation_request, TaskStatus::Cancelled, None)
+        .await?;
+
+    Ok(CancelStatus::Ok)
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(cancel_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<ProverState> {
+    Router::new().route("/", post(cancel_handler))
+}

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

@@ -12,6 +12,10 @@ use crate::{
     Message, ProverState,
 };
 
+pub mod cancel;
+pub mod prune;
+pub mod report;
+
 #[utoipa::path(post, path = "/proof/aggregate",
     tag = "Proving",
     request_body = AggregationRequest,
@@ -106,9 +110,22 @@ async fn aggregation_handler(
 struct Docs;
 
 pub fn create_docs() -> utoipa::openapi::OpenApi {
-    Docs::openapi()
+    [
+        cancel::create_docs(),
+        report::create_docs(),
+        prune::create_docs(),
+    ]
+    .into_iter()
+    .fold(Docs::openapi(), |mut docs, curr| {
+        docs.merge(curr);
+        docs
+    })
 }
 
 pub fn create_router() -> Router<ProverState> {
-    Router::new().route("/", post(aggregation_handler))
+    Router::new()
+        .route("/", post(aggregation_handler))
+        .nest("/cancel", cancel::create_router())
+        .nest("/prune", prune::create_router())
+        .nest("/report", report::create_router())
 }

host/src/server/api/v3/proof/aggregate/prune.rs

@@ -0,0 +1,33 @@
+use axum::{debug_handler, extract::State, routing::post, Router};
+use raiko_tasks::TaskManager;
+use utoipa::OpenApi;
+
+use crate::{interfaces::HostResult, server::api::v2::PruneStatus, ProverState};
+
+#[utoipa::path(post, path = "/proof/aggregate/prune",
+    tag = "Proving",
+    responses (
+        (status = 200, description = "Successfully pruned all aggregation tasks", body = PruneStatus)
+    )
+)]
+#[debug_handler(state = ProverState)]
+/// Prune all aggregation tasks.
+async fn prune_handler(State(prover_state): State<ProverState>) -> HostResult<PruneStatus> {
+    let mut manager = prover_state.task_manager();
+
+    manager.prune_aggregation_db().await?;
+
+    Ok(PruneStatus::Ok)
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(prune_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<ProverState> {
+    Router::new().route("/", post(prune_handler))
+}

host/src/server/api/v3/proof/aggregate/report.rs

@@ -0,0 +1,37 @@
+use axum::{debug_handler, extract::State, routing::get, Json, Router};
+use raiko_tasks::{AggregationTaskReport, TaskManager};
+use utoipa::OpenApi;
+
+use crate::{interfaces::HostResult, ProverState};
+
+#[utoipa::path(post, path = "/proof/aggregate/report",
+    tag = "Proving",
+    responses (
+        (status = 200, description = "Successfully retrieved a report of all aggregation tasks", body = AggregationTaskReport)
+    )
+)]
+#[debug_handler(state = ProverState)]
+/// List all aggregation tasks.
+///
+/// Retrieve a list of aggregation task reports.
+async fn report_handler(
+    State(prover_state): State<ProverState>,
+) -> HostResult<Json<Vec<AggregationTaskReport>>> {
+    let mut manager = prover_state.task_manager();
+
+    let task_report = manager.list_all_aggregation_tasks().await?;
+
+    Ok(Json(task_report))
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(report_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<ProverState> {
+    Router::new().route("/", get(report_handler))
+}