chore(repo): merge updates from main

taikoxyz · May 25, 2024 · f8011b4 · f8011b4
1 parent 3a9bf8d
commit f8011b4
Show file tree

Hide file tree

Showing 6 changed files with 14 additions and 48 deletions.
diff --git a/core/src/interfaces.rs b/core/src/interfaces.rs
@@ -4,7 +4,6 @@ use alloy_primitives::{Address, B256};
 use clap::{Args, ValueEnum};
 use raiko_lib::{
     input::{GuestInput, GuestOutput},
-    protocol_instance::ProtocolInstance,
     prover::{Proof, Prover, ProverError},
 };
 use serde::{Deserialize, Serialize};
@@ -124,31 +123,6 @@ impl FromStr for ProofType {
 }
 
 impl ProofType {
-    /// Get the instance hash for the protocol instance depending on the proof type.
-    pub fn instance_hash(&self, pi: ProtocolInstance) -> RaikoResult<B256> {
-        match self {
-            ProofType::Native => Ok(NativeProver::instance_hash(pi)),
-            ProofType::Sp1 => {
-                #[cfg(feature = "sp1")]
-                return Ok(sp1_driver::Sp1Prover::instance_hash(pi));
-
-                Err(RaikoError::FeatureNotSupportedError(self.clone()))
-            }
-            ProofType::Risc0 => {
-                #[cfg(feature = "risc0")]
-                return Ok(risc0_driver::Risc0Prover::instance_hash(pi));
-
-                Err(RaikoError::FeatureNotSupportedError(self.clone()))
-            }
-            ProofType::Sgx => {
-                #[cfg(feature = "sgx")]
-                return Ok(sgx_prover::SgxProver::instance_hash(pi));
-
-                Err(RaikoError::FeatureNotSupportedError(self.clone()))
-            }
-        }
-    }
-
     /// Run the prover driver depending on the proof type.
     pub async fn run_prover(
         &self,

diff --git a/core/src/lib.rs b/core/src/lib.rs
@@ -4,9 +4,9 @@ use alloy_primitives::{Address, FixedBytes};
 use alloy_rpc_types::EIP1186AccountProofResponse;
 use raiko_lib::{
     builder::{BlockBuilderStrategy, TaikoStrategy},
-    consts::ChainSpec,
+    consts::{ChainSpec, VerifierType},
     input::{GuestInput, GuestOutput, TaikoProverData},
-    protocol_instance::assemble_protocol_instance,
+    protocol_instance::ProtocolInstance,
     prover::Proof,
     utils::HeaderHasher,
 };
@@ -69,10 +69,7 @@ impl Raiko {
                 info!("Verifying final state using provider data ...");
                 info!("Final block hash derived successfully. {}", header.hash());
                 info!("Final block header derived successfully. {header:?}");
-                let pi = self
-                    .request
-                    .proof_type
-                    .instance_hash(assemble_protocol_instance(input, &header)?)?;
+                let pi = ProtocolInstance::new(input, &header, VerifierType::None)?.instance_hash();
 
                 // Check against the expected value of all fields for easy debugability
                 let exp = &input.block_header_reference;

diff --git a/core/src/prover.rs b/core/src/prover.rs
@@ -1,7 +1,7 @@
-use alloy_primitives::B256;
 use raiko_lib::{
+    consts::VerifierType,
     input::{GuestInput, GuestOutput},
-    protocol_instance::{assemble_protocol_instance, ProtocolInstance},
+    protocol_instance::ProtocolInstance,
     prover::{to_proof, Proof, Prover, ProverError, ProverResult},
 };
 use serde::{Deserialize, Serialize};
@@ -26,15 +26,11 @@ impl Prover for NativeProver {
             return Err(ProverError::GuestError("Unexpected output".to_owned()));
         };
 
-        assemble_protocol_instance(&input, &header)
+        ProtocolInstance::new(&input, &header, VerifierType::None)
             .map_err(|e| ProverError::GuestError(e.to_string()))?;
 
         to_proof(Ok(NativeResponse {
             output: output.clone(),
         }))
     }
-
-    fn instance_hash(_pi: ProtocolInstance) -> B256 {
-        B256::default()
-    }
 }
diff --git a/host/src/lib.rs b/host/src/lib.rs
@@ -134,9 +134,7 @@ impl ProverState {
         opts.merge_from_file()?;
 
         let chain_specs = if let Some(cs_path) = &opts.chain_spec_path {
-            let chain_specs = SupportedChainSpecs::merge_from_file(cs_path.clone())
-                .unwrap_or(SupportedChainSpecs::default());
-            chain_specs
+            SupportedChainSpecs::merge_from_file(cs_path.clone()).unwrap_or_default()
         } else {
             SupportedChainSpecs::default()
         };

diff --git a/lib/src/consts.rs b/lib/src/consts.rs
@@ -49,16 +49,18 @@ const DEFAULT_CHAIN_SPECS: &str = include_str!("../../host/config/chain_spec_lis
 #[derive(Clone, Debug)]
 pub struct SupportedChainSpecs(HashMap<String, ChainSpec>);
 
-impl SupportedChainSpecs {
-    pub fn default() -> Self {
+impl Default for SupportedChainSpecs {
+    fn default() -> Self {
         let deserialized: Vec<ChainSpec> = serde_json::from_str(DEFAULT_CHAIN_SPECS).unwrap();
         let chain_spec_list = deserialized
             .iter()
             .map(|cs| (cs.name.clone(), cs.clone()))
             .collect::<HashMap<String, ChainSpec>>();
         SupportedChainSpecs(chain_spec_list)
     }
+}
 
+impl SupportedChainSpecs {
     #[cfg(feature = "std")]
     pub fn merge_from_file(file_path: PathBuf) -> Result<SupportedChainSpecs> {
         let mut known_chain_specs = SupportedChainSpecs::default();

diff --git a/lib/src/protocol_instance.rs b/lib/src/protocol_instance.rs
@@ -102,13 +102,12 @@ impl ProtocolInstance {
             .collect::<Vec<_>>();
 
         let gas_limit: u64 = header.gas_limit.try_into().unwrap();
-        let verifier_address = input
+        let verifier_address = (*input
             .chain_spec
             .verifier_address
             .get(&proof_type)
-            .unwrap_or(&None)
-            .clone()
-            .unwrap_or_default();
+            .unwrap_or(&None))
+        .unwrap_or_default();
 
         let pi = ProtocolInstance {
             transition: Transition {