chore: keep pruning

Author: smtmfft

.gitignore

@@ -68,4 +68,5 @@ log.build.*
 # -----------------------------------------------------------------------------------------
 venv/
 .venv/
+*.pyc
 

Dockerfile.zk

@@ -97,7 +97,6 @@ COPY --from=builder /opt/raiko/target/release/raiko-host /opt/raiko/bin/
 # Copy the .env file with RISC0 and SP1 image IDs from builder stage
 COPY --from=builder /opt/raiko/.env /opt/raiko/.env
 # Include only the runtime guest ELF artifacts for SP1 and RISC0
-COPY --from=builder /opt/raiko/provers/sp1/guest/elf/sp1-aggregation /opt/raiko/provers/sp1/elf/sp1-aggregation
 COPY --from=builder /opt/raiko/provers/sp1/guest/elf/sp1-batch /opt/raiko/provers/sp1/elf/sp1-batch
 COPY --from=builder /opt/raiko/provers/sp1/guest/elf/sp1-shasta-aggregation /opt/raiko/provers/sp1/elf/sp1-shasta-aggregation
 COPY --from=builder /opt/raiko/provers/risc0/guest/target/riscv32im-risc0-zkvm-elf/release/boundless-aggregation.bin /opt/raiko/provers/risc0/elf/boundless-aggregation.bin

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

@@ -0,0 +1,28 @@
+use axum::{extract::State, routing::get, Json, Router};
+use serde_json::Value;
+use utoipa::OpenApi;
+
+use crate::interfaces::HostResult;
+use raiko_reqactor::Actor;
+
+#[utoipa::path(post, path = "/proof/list",
+    tag = "Proving",
+    responses (
+        (status = 200, description = "Successfully listed all proofs & Ids", body = CancelStatus)
+    )
+)]
+async fn list_handler(State(_actor): State<Actor>) -> HostResult<Json<Value>> {
+    todo!()
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(list_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<Actor> {
+    Router::new().route("/", get(list_handler))
+}

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

@@ -0,0 +1,41 @@
+use crate::interfaces::HostResult;
+use crate::server::api::v3::PruneStatus;
+use axum::{extract::State, routing::post, Json, Router};
+use raiko_reqactor::Actor;
+use utoipa::OpenApi;
+
+#[utoipa::path(post, path = "/proof/prune",
+    tag = "Proving",
+    responses (
+        (status = 200, description = "Successfully pruned tasks", body = PruneStatus)
+    )
+)]
+/// Prune all tasks.
+async fn prune_handler(State(actor): State<Actor>) -> HostResult<Json<PruneStatus>> {
+    let statuses = actor
+        .pool_list_status()
+        .await
+        .map_err(|e| anyhow::anyhow!(e))?;
+    for (key, status) in statuses {
+        tracing::info!("Pruning task: {key} with status: {status}");
+        let _ = actor
+            .pool_remove_request(&key)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
+        // Also remove from the queue
+        actor.queue_remove(&key).await;
+    }
+    Ok(Json(PruneStatus::Ok))
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(prune_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<Actor> {
+    Router::new().route("/", post(prune_handler))
+}

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

@@ -0,0 +1,106 @@
+use crate::interfaces::HostResult;
+use axum::{extract::State, routing::get, Json, Router};
+use raiko_reqactor::Actor;
+use raiko_reqpool::{RequestKey, Status, StatusWithContext};
+use raiko_tasks::{
+    AggregationTaskDescriptor, BatchGuestInputTaskDescriptor, BatchProofTaskDescriptor,
+    GuestInputTaskDescriptor, ProofTaskDescriptor, ShastaGuestInputTaskDescriptor,
+    ShastaProofTaskDescriptor, TaskDescriptor, TaskReport, TaskStatus,
+};
+use serde_json::Value;
+use utoipa::OpenApi;
+
+#[utoipa::path(post, path = "/proof/report",
+    tag = "Proving",
+    responses (
+        (status = 200, description = "Successfully listed all current tasks")
+    )
+)]
+/// List all tasks.
+///
+/// Retrieve a list of `{ chain_id, blockhash, prover_type, prover, status }` items.
+async fn report_handler(State(actor): State<Actor>) -> HostResult<Json<Value>> {
+    let statuses = actor
+        .pool_list_status()
+        .await
+        .map_err(|e| anyhow::anyhow!(e))?;
+
+    // For compatibility with the old API, we need to convert the statuses to the old format.
+    let to_task_status = |status: StatusWithContext| match status.into_status() {
+        Status::Registered => TaskStatus::Registered,
+        Status::WorkInProgress => TaskStatus::WorkInProgress,
+        Status::Cancelled => TaskStatus::Cancelled,
+        Status::Success { .. } => TaskStatus::Success,
+        Status::Failed { error } => TaskStatus::AnyhowError(error),
+    };
+    let to_task_descriptor = |request_key: RequestKey| match request_key {
+        RequestKey::GuestInput(key) => TaskDescriptor::GuestInput(GuestInputTaskDescriptor {
+            chain_id: *key.chain_id(),
+            block_id: *key.block_number(),
+            blockhash: *key.block_hash(),
+        }),
+        RequestKey::SingleProof(key) => TaskDescriptor::SingleProof(ProofTaskDescriptor {
+            chain_id: *key.chain_id(),
+            block_id: *key.block_number(),
+            blockhash: *key.block_hash(),
+            proof_system: *key.proof_type(),
+            prover: key.prover_address().clone(),
+        }),
+        RequestKey::Aggregation(key) => TaskDescriptor::Aggregation(AggregationTaskDescriptor {
+            aggregation_ids: key.block_numbers().clone(),
+            proof_type: Some(key.proof_type().to_string()),
+        }),
+        RequestKey::BatchProof(key) => TaskDescriptor::BatchProof(BatchProofTaskDescriptor {
+            chain_id: *key.guest_input_key().chain_id(),
+            batch_id: *key.guest_input_key().batch_id(),
+            l1_height: *key.guest_input_key().l1_inclusion_height(),
+            proof_system: *key.proof_type(),
+            prover: key.prover_address().clone(),
+        }),
+        RequestKey::BatchGuestInput(key) => {
+            TaskDescriptor::BatchGuestInput(BatchGuestInputTaskDescriptor {
+                chain_id: *key.chain_id(),
+                batch_id: *key.batch_id(),
+                l1_height: *key.l1_inclusion_height(),
+            })
+        }
+        RequestKey::ShastaGuestInput(key) => {
+            TaskDescriptor::ShastaGuestInput(ShastaGuestInputTaskDescriptor {
+                proposal_id: *key.proposal_id(),
+                l1_network: key.l1_network().clone(),
+                l2_network: key.l2_network().clone(),
+            })
+        }
+        RequestKey::ShastaProof(key) => TaskDescriptor::ShastaProof(ShastaProofTaskDescriptor {
+            proposal_id: *key.guest_input_key().proposal_id(),
+            l1_network: key.guest_input_key().l1_network().clone(),
+            l2_network: key.guest_input_key().l2_network().clone(),
+            proof_system: *key.proof_type(),
+            prover: key.actual_prover_address().clone(),
+        }),
+        RequestKey::ShastaAggregation(key) => {
+            TaskDescriptor::Aggregation(AggregationTaskDescriptor {
+                aggregation_ids: key.block_numbers().clone(),
+                proof_type: Some(key.proof_type().to_string()),
+            })
+        }
+    };
+
+    let task_report: Vec<TaskReport> = statuses
+        .into_iter()
+        .map(|(request_key, status)| (to_task_descriptor(request_key), to_task_status(status)))
+        .collect();
+    Ok(Json(serde_json::to_value(task_report)?))
+}
+
+#[derive(OpenApi)]
+#[openapi(paths(report_handler))]
+struct Docs;
+
+pub fn create_docs() -> utoipa::openapi::OpenApi {
+    Docs::openapi()
+}
+
+pub fn create_router() -> Router<Actor> {
+    Router::new().route("/", get(report_handler))
+}

provers/risc0/builder/src/main.rs

@@ -14,7 +14,7 @@ fn main() {
         "provers/risc0/driver/src/methods",
     );
     #[cfg(feature = "test")]
-    pipeline.tests(&["risc0-batch"], "provers/risc0/driver/src/methods");
+    pipeline.tests(&["boundless-batch"], "provers/risc0/driver/src/methods");
     #[cfg(feature = "bench")]
     pipeline.bins(&["ecdsa", "sha256"], "provers/risc0/driver/src/methods");
 }

provers/risc0/driver/src/lib.rs

@@ -399,16 +399,16 @@ fn build_shasta_block_inputs(
 mod test {
     use super::*;
     use methods::boundless_batch::BOUNDLESS_BATCH_ID as RISC0_BATCH_ID;
-    use methods::test_risc0_batch::{TEST_RISC0_BATCH_ELF, TEST_RISC0_BATCH_ID};
+    use methods::test_boundless_batch::{TEST_BOUNDLESS_BATCH_ELF, TEST_BOUNDLESS_BATCH_ID};
     use risc0_zkvm::{default_prover, ExecutorEnv};
 
     #[test]
     fn run_unittest_elf() {
         std::env::set_var("RISC0_PROVER", "local");
         let env = ExecutorEnv::builder().build().unwrap();
         let prover = default_prover();
-        let receipt = prover.prove(env, TEST_RISC0_BATCH_ELF).unwrap();
-        receipt.receipt.verify(TEST_RISC0_BATCH_ID).unwrap();
+        let receipt = prover.prove(env, TEST_BOUNDLESS_BATCH_ELF).unwrap();
+        receipt.receipt.verify(TEST_BOUNDLESS_BATCH_ID).unwrap();
     }
 
     #[ignore = "only to print image id for docker image build"]

provers/risc0/driver/src/methods/mod.rs

@@ -10,4 +10,4 @@ pub mod ecdsa;
 #[cfg(feature = "bench")]
 pub mod sha256;
 #[cfg(test)]
-pub mod test_risc0_batch;
+pub mod test_boundless_batch;