fix(raiko): removed panic stabilization

harness/core/src/assert.rs

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, sync::Mutex};
+use std::fmt::Debug;
 
 pub trait DynAssertion: Send + Sync {
     fn display(&self);
@@ -99,9 +99,7 @@ pub fn eval_assert_eq<T: PartialEq + std::fmt::Debug>(a: T, b: T, file: &str, li
 macro_rules! assert {
     ($cond:expr) => {
         let result = eval_assert(false, file!(), line!());
-        let log = $crate::ASSERTION_LOG.get_or_init(
-            || std::sync::Mutex::new(AssertionLog::new())
-        );
+        let log = $crate::ASSERTION_LOG.get_or_init(|| std::sync::Mutex::new(AssertionLog::new()));
         log.lock()
             .unwrap()
             .insert(Box::new(Assertion::<bool>::Cond(Assert { result })));
@@ -111,9 +109,7 @@ macro_rules! assert {
 macro_rules! assert_eq {
     ($a:expr, $b:expr) => {
         let result = eval_assert_eq($a, $b, file!(), line!());
-        let log = $crate::ASSERTION_LOG.get_or_init(
-            || std::sync::Mutex::new(AssertionLog::new())
-        );
+        let log = $crate::ASSERTION_LOG.get_or_init(|| std::sync::Mutex::new(AssertionLog::new()));
         log.lock()
             .unwrap()
             .insert(Box::new(Assertion::<i32>::Eq(AssertEQ {

host/src/interfaces/request.rs

@@ -77,19 +77,22 @@ impl ProofType {
                 #[cfg(feature = "sp1")]
                 return Ok(sp1_driver::Sp1Prover::instance_hash(pi));
 
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                #[cfg(not(feature = "sp1"))]
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
             ProofType::Risc0 => {
                 #[cfg(feature = "risc0")]
                 return Ok(risc0_driver::Risc0Prover::instance_hash(pi));
 
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                #[cfg(not(feature = "risc0"))]
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
             ProofType::Sgx => {
                 #[cfg(feature = "sgx")]
                 return Ok(sgx_prover::SgxProver::instance_hash(pi));
 
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                #[cfg(not(feature = "sgx"))]
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
         }
     }
@@ -111,23 +114,24 @@ impl ProofType {
                     .await
                     .map_err(|e| e.into());
                 #[cfg(not(feature = "sp1"))]
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
             ProofType::Risc0 => {
                 #[cfg(feature = "risc0")]
                 return risc0_driver::Risc0Prover::run(input, output, config)
                     .await
                     .map_err(|e| e.into());
                 #[cfg(not(feature = "risc0"))]
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
             ProofType::Sgx => {
                 #[cfg(feature = "sgx")]
                 return sgx_prover::SgxProver::run(input, output, config)
                     .await
                     .map_err(|e| e.into());
+
                 #[cfg(not(feature = "sgx"))]
-                Err(HostError::FeatureNotSupportedError(self.clone()))
+                return Err(HostError::FeatureNotSupportedError(self.clone()));
             }
         }
     }

host/src/raiko.rs

@@ -113,11 +113,9 @@ impl Raiko {
                 );
 
                 // Make sure the blockhash from the node matches the one from the builder
-                check_eq(
-                    &Into::<FixedBytes<32>>::into(header.hash().0),
-                    &input.block_hash_reference,
-                    "block hash unexpected",
-                );
+                if &Into::<FixedBytes<32>>::into(header.hash().0) != &input.block_hash_reference {
+                    return Err(anyhow::Error::msg("block hash unexpected").into());
+                }
                 let output = GuestOutput::Success { header, hash: pi };
 
                 Ok(output)

provers/risc0/driver/src/bonsai.rs

@@ -1,5 +1,4 @@
 use log::{debug, error, info, warn};
-use raiko_lib::prover::Prover;
 use raiko_primitives::keccak::keccak;
 use risc0_zkvm::{
     compute_image_id, is_dev_mode, serde::to_vec, sha::Digest, Assumption, ExecutorEnv,

provers/risc0/driver/src/lib.rs

@@ -21,7 +21,6 @@ pub mod bonsai;
 pub mod methods;
 pub mod snarks;
 use crate::snarks::verify_groth16_snark;
-use bonsai::maybe_prove;
 pub use bonsai::*;
 use methods::risc0_guest::{RISC0_GUEST_ELF, RISC0_GUEST_ID};
 

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

@@ -1,7 +1,6 @@
 pub const RISC0_GUEST_ELF: &[u8] =
     include_bytes!("../../../guest/target/riscv32im-risc0-zkvm-elf/release/risc0-guest");
 pub const RISC0_GUEST_ID: [u32; 8] = [
-    2669471478, 2370976086, 1239099654, 3456690507, 387711042, 2480181200, 3781663788, 2654654325,
+    2913493253, 3394948572, 1016455208, 2248481430, 1003343387, 1683995099, 2606924676, 3573161770,
 ];
-pub const RISC0_GUEST_PATH: &str =
-    r#"/home/ubuntu/raiko/provers/risc0/guest/target/riscv32im-risc0-zkvm-elf/release/risc0-guest"#;
+pub const RISC0_GUEST_PATH: &str = r#"/home/jony/projects/rust/taiko/raiko/provers/risc0/guest/target/riscv32im-risc0-zkvm-elf/release/risc0-guest"#;

provers/sp1/guest/src/zk_op.rs

@@ -27,7 +27,7 @@ impl ZkvmOperator for Sp1Operator {
             .map(|chunk| u32::from_le_bytes(chunk.try_into().unwrap()))
             .collect::<Vec<u32>>()
             .try_into()
-            .map_err(|e| Error::ZkvmOperation("Input point processing failed".to_string()))?;
+            .map_err(|_| Error::ZkvmOperation("Input point processing failed: {}".to_string()))?;
 
         p.mul_assign(&k);
         Ok(point_to_be_bytes(p))
@@ -98,7 +98,6 @@ fn point_to_be_bytes(p: AffinePoint<Bn254, 16>) -> [u8; 64] {
     ([x, y]).concat().try_into().unwrap()
 }
 
-
 harness::zk_suits!(
     pub mod tests {
         use revm_precompile::bn128;