chore: remove deps on zkm-prover (#60)

* feat: remove zkm prover

* fix: polish code

* fix steps

* chore: code polishing

* chore: code polishing

Author: eigmax

sdk/README.md

@@ -26,7 +26,7 @@ zkm-sdk = { git = "https://github.com/zkMIPS/zkm-project-template", branch = "ma
 
 ## Don't use the libsnark
 
-1. Set the environment variable `NO_USE_SNARK=true` .
+1. Set the environment variable `USE_LOCAL_PROVER=true` .
 
 2. Import the SDK
 

sdk/build.rs

@@ -16,7 +16,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         panic!("Go build failed");
     }
 
-    if let Some(_snark_flag) = std::env::var_os("NO_USE_SNARK") {
+    if std::env::var_os("USE_LOCAL_PROVER").is_some() {
         tonic_build::configure()
             .protoc_arg("--experimental_allow_proto3_optional")
             .compile(&["src/proto/stage.proto"], &["src/proto"])?;

sdk/src/network/prover.rs

@@ -12,6 +12,7 @@ use ethers::signers::{LocalWallet, Signer};
 use tokio::time::sleep;
 use tokio::time::Duration;
 
+use anyhow::{bail, Result};
 use async_trait::async_trait;
 
 #[derive(Clone)]
@@ -24,7 +25,7 @@ pub mod stage_service {
     tonic::include_proto!("stage.v1");
 }
 
-use crate::network::prover::stage_service::Status;
+use crate::network::prover::stage_service::{Status, Step};
 
 pub struct NetworkProver {
     pub stage_client: StageServiceClient<Channel>,
@@ -83,7 +84,7 @@ impl NetworkProver {
         request.signature = signature.to_string();
     }
 
-    pub async fn download_file(url: &str) -> anyhow::Result<Vec<u8>> {
+    pub async fn download_file(url: &str) -> Result<Vec<u8>> {
         let response = reqwest::get(url).await?;
         let content = response.bytes().await?;
         Ok(content.to_vec())
@@ -92,7 +93,7 @@ impl NetworkProver {
 
 #[async_trait]
 impl Prover for NetworkProver {
-    async fn request_proof<'a>(&self, input: &'a ProverInput) -> anyhow::Result<String> {
+    async fn request_proof<'a>(&self, input: &'a ProverInput) -> Result<String> {
         let proof_id = uuid::Uuid::new_v4().to_string();
         let mut request = GenerateProofRequest {
             proof_id: proof_id.clone(),
@@ -120,7 +121,7 @@ impl Prover for NetworkProver {
         &self,
         proof_id: &'a str,
         timeout: Option<Duration>,
-    ) -> anyhow::Result<Option<ProverResult>> {
+    ) -> Result<Option<ProverResult>> {
         let start_time = Instant::now();
         let mut split_start_time = Instant::now();
         let mut split_end_time = Instant::now();
@@ -129,7 +130,7 @@ impl Prover for NetworkProver {
         loop {
             if let Some(timeout) = timeout {
                 if start_time.elapsed() > timeout {
-                    return Err(anyhow::anyhow!("Proof generation timed out."));
+                    bail!("Proof generation timed out.");
                 }
             }
 
@@ -139,25 +140,27 @@ impl Prover for NetworkProver {
             match Status::from_i32(get_status_response.status as i32) {
                 Some(Status::Computing) => {
                     //log::info!("generate_proof step: {}", get_status_response.step);
-                    match get_status_response.step {
-                        0 => log::info!("generate_proof : queuing the task."),
-                        1 => {
+                    match Step::from_i32(get_status_response.step) {
+                        Some(Step::Init) => log::info!("generate_proof : queuing the task."),
+                        Some(Step::InSplit) => {
                             if last_step == 0 {
                                 split_start_time = Instant::now();
                             }
                             log::info!("generate_proof : splitting the task.");
                         }
-                        2 => {
+                        Some(Step::InProve) => {
                             if last_step == 1 {
                                 split_end_time = Instant::now();
                             }
                             log::info!("generate_proof : proving the task.");
                         }
-                        3 => log::info!("generate_proof : aggregating the proof."),
-                        4 => log::info!("generate_proof : aggregating the proof."),
-                        5 => log::info!("generate_proof : finalizing the proof."),
-                        6 => log::info!("generate_proof : completing the proof."),
-                        i32::MIN..=-1_i32 | 7_i32..=i32::MAX => todo!(),
+                        Some(Step::InAgg) => log::info!("generate_proof : aggregating the proof."),
+                        Some(Step::InAggAll) => {
+                            log::info!("generate_proof : aggregating the proof.")
+                        }
+                        Some(Step::InFinal) => log::info!("generate_proof : finalizing the proof."),
+                        Some(Step::End) => log::info!("generate_proof : completing the proof."),
+                        None => todo!(),
                     }
                     last_step = get_status_response.step;
                     sleep(Duration::from_secs(30)).await;
@@ -195,11 +198,7 @@ impl Prover for NetworkProver {
                 }
                 _ => {
                     log::error!("generate_proof failed status: {}", get_status_response.status);
-                    //return Ok(None);
-                    return Err(anyhow::anyhow!(
-                        "generate_proof failed status: {}",
-                        get_status_response.status
-                    ));
+                    bail!("generate_proof failed status: {}", get_status_response.status);
                 }
             }
         }
@@ -210,17 +209,15 @@ impl Prover for NetworkProver {
         _vk_path: &'a str,
         _input: &'a ProverInput,
         _timeout: Option<Duration>,
-    ) -> anyhow::Result<()> {
-        log::info!("The proof network does not support the method.");
-
+    ) -> Result<()> {
         panic!("The proof network does not support the method!");
     }
 
     async fn prove<'a>(
         &self,
         input: &'a ProverInput,
         timeout: Option<Duration>,
-    ) -> anyhow::Result<Option<ProverResult>> {
+    ) -> Result<Option<ProverResult>> {
         log::info!("calling request_proof.");
         let proof_id = self.request_proof(input).await?;
         log::info!("calling wait_proof, proof_id={}", proof_id);

sdk/src/proto/stage.proto

@@ -74,9 +74,9 @@ message GetStatusResponse {
     string stark_proof_url = 5;
     string solidity_verifier_url = 6;
     bytes output_stream = 7;
-    int32 step = 8; // Step
+    Step step = 8; // Step
     string public_values_url = 9;
     uint64 total_steps = 10;
     bytes receipt = 11;
     bytes elf_id = 12;
-}
+}