Stwobackend prover skeleton

backend/Cargo.toml

@@ -12,6 +12,7 @@ default = []
 halo2 = ["dep:halo2_proofs", "dep:halo2_curves", "dep:snark-verifier", "dep:halo2_solidity_verifier"]
 estark-polygon = ["dep:pil-stark-prover"]
 plonky3 = ["dep:powdr-plonky3"]
+stwo = ["dep:stwo-prover"]
 
 [dependencies]
 powdr-ast.workspace = true
@@ -35,6 +36,9 @@ halo2_curves = { version = "0.6.1", package = "halo2curves", optional = true}
 snark-verifier = { git = "https://github.com/powdr-labs/snark-verifier", branch = "powdr-halo2", optional = true }
 halo2_solidity_verifier = { git = "https://github.com/powdr-labs/halo2-solidity-verifier", branch = "main", features = ["evm"], optional = true }
 
+#change this to main branch when updatetoolchain branch is merged,the main branch is using "nightly-2024-01-04", not compatiable with plonky3
+stwo-prover = { git= "https://github.com/starkware-libs/stwo.git",optional=true, rev="52d050c18b5dbc74af40214b3b441a6f60a20d41" }
+
 strum = { version = "0.24.1", features = ["derive"] }
 log = "0.4.17"
 serde = "1.0"

backend/src/lib.rs

@@ -8,6 +8,7 @@ mod plonky3;
 
 mod composite;
 mod field_filter;
+mod stwo;
 
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::{constant_evaluator::VariablySizedColumn, witgen::WitgenCallback};
@@ -49,6 +50,9 @@ pub enum BackendType {
     #[cfg(feature = "plonky3")]
     #[strum(serialize = "plonky3-composite")]
     Plonky3Composite,
+    #[cfg(feature = "stwo")]
+    #[strum(serialize = "stwo")]
+    Stwo,
 }
 
 pub type BackendOptions = String;
@@ -91,6 +95,8 @@ impl BackendType {
             BackendType::Plonky3Composite => {
                 Box::new(composite::CompositeBackendFactory::new(plonky3::Factory))
             }
+            #[cfg(feature = "stwo")]
+            BackendType::Stwo => Box::new(stwo::StwoProverFactory),
         }
     }
 }

backend/src/stwo/mod.rs

@@ -0,0 +1,68 @@
+use log::info;
+use std::io;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use crate::{Backend, BackendFactory, BackendOptions, Error, Proof};
+use powdr_ast::analyzed::Analyzed;
+use powdr_executor::constant_evaluator::{get_uniquely_sized_cloned, VariablySizedColumn};
+use powdr_executor::witgen::WitgenCallback;
+use powdr_number::FieldElement;
+use prover::StwoProver;
+
+mod prover;
+
+#[allow(dead_code)]
+pub(crate) struct StwoProverFactory;
+
+impl<F: FieldElement> BackendFactory<F> for StwoProverFactory {
+    #[allow(unreachable_code)]
+    #[allow(unused_variables)]
+    fn create(
+        &self,
+        pil: Arc<Analyzed<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
+        _output_dir: Option<PathBuf>,
+        setup: Option<&mut dyn io::Read>,
+        verification_key: Option<&mut dyn io::Read>,
+        verification_app_key: Option<&mut dyn io::Read>,
+        options: BackendOptions,
+    ) -> Result<Box<dyn crate::Backend<F>>, Error> {
+        if pil.degrees().len() > 1 {
+            return Err(Error::NoVariableDegreeAvailable);
+        }
+        let fixed = Arc::new(
+            get_uniquely_sized_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?,
+        );
+        let stwo = Box::new(StwoProver::new(pil, fixed, setup)?);
+        info!("StwoProverFactory is not complete yet");
+        Ok(stwo)
+    }
+}
+
+impl<T: FieldElement> Backend<T> for StwoProver<T> {
+    #[allow(unused_variables)]
+    fn verify(&self, proof: &[u8], instances: &[Vec<T>]) -> Result<(), Error> {
+        assert!(instances.len() == 1);
+        Ok(())
+    }
+    #[allow(unreachable_code)]
+    #[allow(unused_variables)]
+    fn prove(
+        &self,
+        witness: &[(String, Vec<T>)],
+        prev_proof: Option<Proof>,
+        witgen_callback: WitgenCallback<T>,
+    ) -> Result<Proof, Error> {
+        if prev_proof.is_some() {
+            return Err(Error::NoAggregationAvailable);
+        }
+        let proof = vec![0u8; 10];
+        panic!("prove function is not implement yet");
+        Ok(proof)
+    }
+    #[allow(unused_variables)]
+    fn export_verification_key(&self, output: &mut dyn io::Write) -> Result<(), Error> {
+        Ok(())
+    }
+}

backend/src/stwo/prover.rs

@@ -0,0 +1,32 @@
+use powdr_ast::analyzed::Analyzed;
+use std::io;
+use std::sync::Arc;
+
+use powdr_number::FieldElement;
+
+#[allow(unused_variables)]
+pub struct StwoProver<F> {
+    _analyzed: Arc<Analyzed<F>>,
+    _fixed: Arc<Vec<(String, Vec<F>)>>,
+    /// Proving key placeholder
+    _proving_key: Option<()>,
+    /// Verifying key placeholder
+    _verifying_key: Option<()>,
+}
+
+impl<F: FieldElement> StwoProver<F> {
+    #[allow(dead_code)]
+    #[allow(unused_variables)]
+    pub fn new(
+        _analyzed: Arc<Analyzed<F>>,
+        _fixed: Arc<Vec<(String, Vec<F>)>>,
+        setup: Option<&mut dyn io::Read>,
+    ) -> Result<Self, io::Error> {
+        Ok(Self {
+            _analyzed,
+            _fixed,
+            _proving_key: None,
+            _verifying_key: None,
+        })
+    }
+}

cli/Cargo.toml

@@ -16,6 +16,7 @@ estark-polygon = [
   "powdr-backend/estark-polygon",
   "powdr-pipeline/estark-polygon",
 ]
+stwo=["powdr-backend/stwo","powdr-pipeline/stwo"]
 
 [dependencies]
 powdr-backend.workspace = true

pipeline/Cargo.toml

@@ -12,6 +12,7 @@ default = [] # halo2 is disabled by default
 halo2 = ["powdr-backend/halo2"]
 plonky3 = ["powdr-backend/plonky3"]
 estark-polygon = ["powdr-backend/estark-polygon"]
+stwo = ["powdr-backend/stwo"]
 
 [dependencies]
 powdr-airgen.workspace = true