initial powdr support

Author: leonardoalt

Cargo.toml

@@ -7,6 +7,8 @@ members = [
     "harness/macro",
     "provers/sp1/driver",
     "provers/sp1/builder",
+    "provers/powdr/driver",
+    "provers/powdr/builder",
     "provers/risc0/driver",
     "provers/risc0/builder",
     "provers/sgx/prover",

core/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 # provers
 sp1-driver = { path = "../provers/sp1/driver", optional = true }
 risc0-driver = { path = "../provers/risc0/driver", optional = true }
+powdr-driver = { path = "../provers/powdr/driver", optional = true }
 sgx-prover = { path = "../provers/sgx/prover", optional = true }
 
 # raiko
@@ -69,4 +70,5 @@ ethers-core = { workspace = true }
 # powdr = ["dep:powdr"]
 sp1 = ["dep:sp1-driver", "sp1-driver/enable"]
 risc0 = ["dep:risc0-driver", "risc0-driver/enable"]
+powdr = ["dep:powdr-driver", "powdr-driver/enable"]
 sgx = ["dep:sgx-prover", "sgx-prover/enable"]

core/src/interfaces.rs

@@ -113,6 +113,10 @@ pub enum ProofType {
     ///
     /// Uses the RISC0 prover to build the block.
     Risc0,
+    /// # powdr
+    ///
+    /// Uses powdrVM to build the block.
+    Powdr,
 }
 
 impl std::fmt::Display for ProofType {
@@ -122,6 +126,7 @@ impl std::fmt::Display for ProofType {
             ProofType::Sp1 => "sp1",
             ProofType::Sgx => "sgx",
             ProofType::Risc0 => "risc0",
+            ProofType::Powdr => "powdr",
         })
     }
 }
@@ -135,6 +140,7 @@ impl FromStr for ProofType {
             "sp1" => Ok(ProofType::Sp1),
             "sgx" => Ok(ProofType::Sgx),
             "risc0" => Ok(ProofType::Risc0),
+            "powdr" => Ok(ProofType::Powdr),
             _ => Err(RaikoError::InvalidProofType(s.to_string())),
         }
     }
@@ -149,6 +155,7 @@ impl TryFrom<u8> for ProofType {
             1 => Ok(Self::Sp1),
             2 => Ok(Self::Sgx),
             3 => Ok(Self::Risc0),
+            4 => Ok(Self::Powdr),
             _ => Err(RaikoError::Conversion("Invalid u8".to_owned())),
         }
     }
@@ -161,6 +168,7 @@ impl From<ProofType> for VerifierType {
             ProofType::Sp1 => VerifierType::SP1,
             ProofType::Sgx => VerifierType::SGX,
             ProofType::Risc0 => VerifierType::RISC0,
+            ProofType::Powdr => VerifierType::Powdr,
         }
     }
 }
@@ -194,6 +202,14 @@ impl ProofType {
                 #[cfg(not(feature = "risc0"))]
                 Err(RaikoError::FeatureNotSupportedError(*self))
             }
+            ProofType::Powdr => {
+                #[cfg(feature = "powdr")]
+                return powdr_driver::PowdrProver::run(input.clone(), output, config, store)
+                    .await
+                    .map_err(|e| e.into());
+                #[cfg(not(feature = "powdr"))]
+                Err(RaikoError::FeatureNotSupportedError(*self))
+            }
             ProofType::Sgx => {
                 #[cfg(feature = "sgx")]
                 return sgx_prover::SgxProver::run(input.clone(), output, config, store)
@@ -233,6 +249,14 @@ impl ProofType {
                 #[cfg(not(feature = "risc0"))]
                 Err(RaikoError::FeatureNotSupportedError(*self))
             }
+            ProofType::Powdr => {
+                #[cfg(feature = "powdr")]
+                return powdr_driver::PowdrProver::aggregate(input.clone(), output, config, store)
+                    .await
+                    .map_err(|e| e.into());
+                #[cfg(not(feature = "powdr"))]
+                Err(RaikoError::FeatureNotSupportedError(*self))
+            }
             ProofType::Sgx => {
                 #[cfg(feature = "sgx")]
                 return sgx_prover::SgxProver::aggregate(input.clone(), output, config, store)
@@ -271,6 +295,14 @@ impl ProofType {
                 #[cfg(not(feature = "risc0"))]
                 Err(RaikoError::FeatureNotSupportedError(*self))
             }
+            ProofType::Powdr => {
+                #[cfg(feature = "powdr")]
+                return powdr_driver::PowdrProver::cancel(proof_key, read)
+                    .await
+                    .map_err(|e| e.into());
+                #[cfg(not(feature = "powdr"))]
+                Err(RaikoError::FeatureNotSupportedError(*self))
+            }
             ProofType::Sgx => {
                 #[cfg(feature = "sgx")]
                 return sgx_prover::SgxProver::cancel(proof_key, read)
@@ -355,6 +387,8 @@ pub struct ProverSpecificOpts {
     pub sp1: Option<Value>,
     /// RISC0 prover specific options.
     pub risc0: Option<Value>,
+    /// Powdr prover specific options.
+    pub powdr: Option<Value>,
 }
 
 impl<S: ::std::hash::BuildHasher + ::std::default::Default> From<ProverSpecificOpts>

core/src/lib.rs

@@ -274,6 +274,14 @@ mod tests {
                 }
             },
         );
+        prover_args.insert(
+            "powdr".to_string(),
+            json! {
+                {
+                    "prover": "mock",
+                }
+            },
+        );
         prover_args.insert(
             "sgx".to_string(),
             json! {

harness/macro/Cargo.toml

@@ -10,9 +10,10 @@ proc-macro = true
 
 [dependencies]
 syn = { workspace = true }
-quote =  { workspace = true }
-proc-macro2 =  { workspace = true }
+quote = { workspace = true }
+proc-macro2 = { workspace = true }
 
 [features]
 sp1 = []
-risc0 = []
+risc0 = []
+powdr = []

harness/macro/src/lib.rs

@@ -3,17 +3,17 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, Item, ItemFn, ItemMod};
 
-#[cfg(any(feature = "sp1", feature = "risc0"))]
+#[cfg(any(feature = "sp1", feature = "risc0", feature = "powdr"))]
 use syn::{punctuated::Punctuated, Ident, Path, Token};
 
 // Helper struct to parse input
-#[cfg(any(feature = "sp1", feature = "risc0"))]
+#[cfg(any(feature = "sp1", feature = "risc0", feature = "powdr"))]
 struct EntryArgs {
     main_entry: Ident,
     test_modules: Option<Punctuated<Path, Token![,]>>,
 }
 
-#[cfg(any(feature = "sp1", feature = "risc0"))]
+#[cfg(any(feature = "sp1", feature = "risc0", feature = "powdr"))]
 impl syn::parse::Parse for EntryArgs {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let main_entry: Ident = input.parse()?;
@@ -33,7 +33,7 @@ impl syn::parse::Parse for EntryArgs {
 }
 
 #[proc_macro]
-#[cfg(any(feature = "sp1", feature = "risc0"))]
+#[cfg(any(feature = "sp1", feature = "risc0", feature = "powdr"))]
 pub fn entrypoint(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as EntryArgs);
     let main_entry = input.main_entry;
@@ -100,11 +100,29 @@ pub fn entrypoint(input: TokenStream) -> TokenStream {
         }
     };
 
+    #[cfg(feature = "powdr")]
+    let output = quote! {
+        #[cfg(test)]
+        #tests_entry
+
+        #[cfg(not(test))]
+        const ZKVM_ENTRY: fn() = #main_entry;
+        #[cfg(test)]
+        const ZKVM_ENTRY: fn() = run_tests;
+
+        mod zkvm_generated_main {
+            #[no_mangle]
+            fn main() {
+                super::ZKVM_ENTRY()
+            }
+        }
+    };
+
     output.into()
 }
 
 #[proc_macro]
-#[cfg(not(any(feature = "sp1", feature = "risc0")))]
+#[cfg(not(any(feature = "sp1", feature = "risc0", feature = "powdr")))]
 pub fn entrypoint(_input: TokenStream) -> TokenStream {
     quote! {
         mod generated_main {

host/Cargo.toml

@@ -9,6 +9,7 @@ default-run = "raiko-host"
 # provers
 sp1-driver = { path = "../provers/sp1/driver", optional = true }
 risc0-driver = { path = "../provers/risc0/driver", optional = true }
+powdr-driver = { path = "../provers/powdr/driver", optional = true }
 sgx-prover = { path = "../provers/sgx/prover", optional = true }
 
 # raiko
@@ -86,6 +87,7 @@ ethers-core = { workspace = true }
 default = []
 sp1 = ["raiko-core/sp1"]
 risc0 = ["raiko-core/risc0"]
+powdr = ["raiko-core/powdr"]
 sgx = ["raiko-core/sgx"]
 integration = []
 

host/config/config.json

@@ -24,6 +24,9 @@
 		"prover": "mock",
         "verify": false
 	},
+    "powdr": {
+		"prover": "mock"
+	},
     "native" : {
         "json_guest_input": null
 	}

host/src/server/api/v1/proof.rs

@@ -30,6 +30,7 @@ use super::ProofResponse;
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn proof_handler(
     State(prover_state): State<ProverState>,
     Json(req): Json<Value>,

host/src/server/api/v2/proof/cancel.rs

@@ -22,6 +22,7 @@ use crate::{interfaces::HostResult, server::api::v2::CancelStatus, Message, Prov
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn cancel_handler(
     State(prover_state): State<ProverState>,
     Json(req): Json<Value>,

host/src/server/api/v2/proof/mod.rs

@@ -32,6 +32,7 @@ pub mod report;
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn proof_handler(
     State(prover_state): State<ProverState>,
     Json(req): Json<Value>,

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

@@ -28,6 +28,7 @@ use crate::{
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn aggregation_handler(
     State(prover_state): State<ProverState>,
     Json(mut aggregation_request): Json<AggregationOnlyRequest>,

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

@@ -24,6 +24,7 @@ use crate::{interfaces::HostResult, server::api::v2::CancelStatus, Message, Prov
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn cancel_handler(
     State(prover_state): State<ProverState>,
     Json(mut aggregation_request): Json<AggregationRequest>,

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

@@ -33,6 +33,7 @@ mod cancel;
 /// - sgx - uses the sgx environment to construct a block and produce proof of execution
 /// - sp1 - uses the sp1 prover
 /// - risc0 - uses the risc0 prover
+/// - powdr - uses the powdr prover
 async fn proof_handler(
     State(prover_state): State<ProverState>,
     Json(mut aggregation_request): Json<AggregationRequest>,

host/tests/common/mod.rs

@@ -130,6 +130,7 @@ pub async fn make_request() -> anyhow::Result<ProofRequestOpt> {
             sgx: None,
             sp1: None,
             risc0: None,
+            powdr: None,
         },
     })
 }

lib/Cargo.toml

@@ -75,4 +75,6 @@ std = [
 sgx = []
 sp1 = []
 risc0 = []
-sp1-cycle-tracker = []
+powdr = []
+sp1-cycle-tracker = []
+proof_of_equivalence = []

lib/src/consts.rs

@@ -134,6 +134,7 @@ pub enum VerifierType {
     SGX,
     SP1,
     RISC0,
+    Powdr,
 }
 
 /// Specification of a specific chain.
@@ -397,6 +398,7 @@ mod tests {
                     (VerifierType::SGX, Some(Address::default())),
                     (VerifierType::SP1, None),
                     (VerifierType::RISC0, Some(Address::default())),
+                    (VerifierType::Powdr, None),
                 ]),
             )]),
             genesis_time: 0u64,

lib/src/protocol_instance.rs

@@ -317,6 +317,7 @@ fn get_blob_proof_type(
         VerifierType::SGX => BlobProofType::KzgVersionedHash,
         VerifierType::SP1 => BlobProofType::ProofOfEquivalence,
         VerifierType::RISC0 => BlobProofType::ProofOfEquivalence,
+        VerifierType::Powdr => BlobProofType::ProofOfEquivalence,
     }
 }
 

pipeline/Cargo.toml

@@ -22,3 +22,5 @@ sp1-sdk = { workspace = true, optional = true }
 [features]
 risc0 = ["dep:risc0-binfmt", "dep:pathdiff", "dep:hex"]
 sp1 = ["dep:sp1-sdk"]
+# TODO: make powdr feature work
+powdr = []