fix server_mode error type (#54)

Author: 0xmountaintop

src/main.rs

@@ -290,22 +290,24 @@ fn serve(opts: ServerOpts) {
             let mut circut = circuit_base.clone();
             match reader::load_witness_from_array::<Bn256>(witness) {
                 Ok(witness) => circut.witness = Some(witness),
-                err => return server::ServerResult::any_error(err),
+                err => return server::ServerResult::new(validate_only).any_error(err),
             }
 
             if validate_only {
                 match setup.validate_witness(circut) {
                     Ok(_) => server::ServerResult::new(true).success(),
-                    err => server::ServerResult::any_error(err),
+                    err => server::ServerResult::new(true).any_error(err),
                 }
             } else {
                 let start = std::time::Instant::now();
                 match setup.prove(circut) {
                     Ok(proof) => {
                         let elapsed = start.elapsed().as_secs_f64();
 
-                        let ret = server::ServerResult::new(false);
-                        let mut inner: pb::ProveResponse = ret.into();
+                        let mut inner: pb::ProveResponse = match server::ServerResult::new(false) {
+                            server::ServerResult::ForProve(i) => i,
+                            _ => unreachable!(),
+                        };
 
                         let (inputs, serialized_proof) = bellman_vk_codegen::serialize_proof(&proof);
                         inner.proof = serialized_proof.iter().map(ToString::to_string).collect();
@@ -315,7 +317,7 @@ fn serve(opts: ServerOpts) {
                         server::ServerResult::ForProve(inner).success()
                     }
 
-                    err => server::ServerResult::any_error(err),
+                    err => server::ServerResult::new(false).any_error(err),
                 }
             }
         })

src/server.rs

@@ -9,33 +9,10 @@ use std::collections::VecDeque;
 use std::sync::Arc;
 use tokio::sync::{mpsc, oneshot, Mutex};
 
-#[derive(Clone, Debug, PartialEq)]
-pub struct ErrDetail {
-    is_valid: bool,
-    error_msg: String,
-}
-
 #[derive(Clone, PartialEq)]
 pub enum ServerResult {
     ForValidate(pb::ValidateResponse),
     ForProve(pb::ProveResponse),
-    Error(ErrDetail),
-}
-
-impl From<ServerResult> for pb::ProveResponse {
-    fn from(res: ServerResult) -> Self {
-        match res {
-            ServerResult::ForValidate(resp) => Self {
-                is_valid: resp.is_valid,
-                error_msg: resp.error_msg,
-                time_cost_secs: 0.0,
-                proof: Vec::new(),
-                inputs: Vec::new(),
-            },
-            ServerResult::ForProve(resp) => resp,
-            _ => unreachable!(),
-        }
-    }
 }
 
 impl ServerResult {
@@ -67,19 +44,26 @@ impl ServerResult {
                 inner.error_msg = String::new();
                 Self::ForProve(inner)
             }
-            Self::Error(_) => unreachable!(),
         }
     }
 
-    pub fn any_error<T, E>(err_ret: Result<T, E>) -> Self
+    pub fn any_error<T, E>(self, err_ret: Result<T, E>) -> Self
     where
         T: std::fmt::Debug,
         E: std::fmt::Display,
     {
-        Self::Error(ErrDetail {
-            is_valid: false,
-            error_msg: format!("{}", err_ret.unwrap_err()),
-        })
+        match self {
+            ServerResult::ForValidate(mut inner) => {
+                inner.is_valid = false;
+                inner.error_msg = format!("{}", err_ret.unwrap_err());
+                Self::ForValidate(inner)
+            }
+            ServerResult::ForProve(mut inner) => {
+                inner.is_valid = false;
+                inner.error_msg = format!("{}", err_ret.unwrap_err());
+                Self::ForProve(inner)
+            }
+        }
     }
 }