Adds SPARK

.gitignore

@@ -14,11 +14,16 @@
 *.pkp
 *.pkv
 *.np
+*.sp
+*.spc
+*.spctx
+spark_proofs/
 params_for_recursive_verifier
 params
 artifacts/
 spartan_vm_debug/
 mavros_debug/
+mavros/
 
 # Don't ignore benchmarking artifacts
 !tooling/provekit-bench/benches/*

Cargo.toml

@@ -17,6 +17,7 @@ members = [
   "tooling/provekit-wasm",
   "tooling/verifier-server",
   "ntt",
+  "provekit/spark",
   "poseidon2",
   "playground/passport-input-gen",
 ]
@@ -102,6 +103,7 @@ provekit-ffi = { path = "tooling/provekit-ffi" }
 provekit-gnark = { path = "tooling/provekit-gnark" }
 provekit-prover = { path = "provekit/prover", default-features = false }
 provekit-r1cs-compiler = { path = "provekit/r1cs-compiler" }
+provekit-spark = { path = "provekit/spark" }
 provekit-verifier = { path = "provekit/verifier" }
 provekit-verifier-server = { path = "tooling/verifier-server" }
 provekit-wasm = { path = "tooling/provekit-wasm" }

provekit/common/src/file/binary_format.rs

@@ -18,10 +18,16 @@ pub const PROVER_FORMAT: [u8; 8] = *b"PrvKitPr";
 pub const PROVER_VERSION: (u16, u16) = (1, 2);
 
 pub const VERIFIER_FORMAT: [u8; 8] = *b"PrvKitVr";
-pub const VERIFIER_VERSION: (u16, u16) = (1, 3);
+pub const VERIFIER_VERSION: (u16, u16) = (1, 4);
 
 pub const NOIR_PROOF_SCHEME_FORMAT: [u8; 8] = *b"NrProScm";
 pub const NOIR_PROOF_SCHEME_VERSION: (u16, u16) = (1, 2);
 
 pub const NOIR_PROOF_FORMAT: [u8; 8] = *b"NPSProof";
-pub const NOIR_PROOF_VERSION: (u16, u16) = (1, 1);
+pub const NOIR_PROOF_VERSION: (u16, u16) = (1, 2);
+
+pub const SPARK_PROOF_FORMAT: [u8; 8] = *b"SparkPrf";
+pub const SPARK_PROOF_VERSION: (u16, u16) = (1, 0);
+
+pub const SPARK_CONTEXT_FORMAT: [u8; 8] = *b"SparkCtx";
+pub const SPARK_CONTEXT_VERSION: (u16, u16) = (1, 0);

provekit/common/src/file/io/mod.rs

@@ -3,11 +3,12 @@ mod buf_ext;
 mod counting_writer;
 mod json;
 
+pub use self::bin::Compression;
 use {
     self::{
         bin::{
             deserialize_from_bytes, read_bin, read_hash_config as read_hash_config_bin,
-            serialize_to_bytes, write_bin, Compression,
+            serialize_to_bytes, write_bin,
         },
         buf_ext::BufExt,
         counting_writer::CountingWriter,
@@ -29,7 +30,7 @@ pub trait FileFormat: Serialize + for<'a> Deserialize<'a> {
 }
 
 /// Helper trait to optionally extract hash config.
-pub(crate) trait MaybeHashAware {
+pub trait MaybeHashAware {
     fn maybe_hash_config(&self) -> Option<HashConfig>;
 }
 

provekit/common/src/lib.rs

@@ -1,7 +1,7 @@
 pub mod file;
 pub use file::binary_format;
 pub mod hash_config;
-mod interner;
+pub mod interner;
 mod mavros;
 mod noir_proof_scheme;
 pub mod ntt;
@@ -11,6 +11,7 @@ pub mod prefix_covector;
 mod prover;
 mod r1cs;
 pub mod skyscraper;
+pub mod spark;
 pub mod sparse_matrix;
 mod transcript_sponge;
 pub mod u256_arith;
@@ -32,6 +33,7 @@ pub use {
     prefix_covector::{OffsetCovector, PrefixCovector, SparseCovector},
     prover::{NoirProver, Prover},
     r1cs::R1CS,
+    spark::{MatrixDimensions, SparkSetup, SparkWhirConfigs},
     transcript_sponge::TranscriptSponge,
     verifier::Verifier,
     whir_r1cs::{R1csHash, WhirConfig, WhirR1CSProof, WhirR1CSScheme, WhirZkConfig},

provekit/common/src/spark.rs

@@ -0,0 +1,72 @@
+use {
+    crate::{utils::serde_ark, FieldElement, HashConfig, WhirConfig, WhirR1CSProof},
+    anyhow::{Context, Result},
+    serde::{Deserialize, Serialize},
+    sha3::{Digest, Sha3_256},
+};
+
+/// A single column-axis SPARK query: an evaluation point on the column axis
+/// plus three claimed evaluations (for the A, B, C matrices). The row axis is
+/// shared across all queries in a [`SparkQueryBatch`].
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SparkColQuery {
+    #[serde(with = "serde_ark")]
+    pub col:       Vec<FieldElement>,
+    #[serde(with = "serde_ark")]
+    pub claimed_a: FieldElement,
+    #[serde(with = "serde_ark")]
+    pub claimed_b: FieldElement,
+    #[serde(with = "serde_ark")]
+    pub claimed_c: FieldElement,
+}
+
+/// A batch of SPARK queries that all share the same row evaluation point.
+/// The shared-row invariant is structural: a batch *cannot* express a
+/// mixed-row set, so the SPARK prover and verifier do not need a runtime
+/// check.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SparkQueryBatch {
+    #[serde(with = "serde_ark")]
+    pub row:     Vec<FieldElement>,
+    pub queries: Vec<SparkColQuery>,
+}
+
+impl SparkQueryBatch {
+    /// Stable Fiat-Shamir instance binding for the batch.
+    pub fn hash_bytes(&self) -> Result<[u8; 32]> {
+        let bytes =
+            postcard::to_allocvec(self).context("serializing SparkQueryBatch for hash_bytes")?;
+        Ok(Sha3_256::digest(&bytes).into())
+    }
+}
+
+/// Dimensions of the (padded) sparse R1CS matrix that SPARK is committing to.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct MatrixDimensions {
+    pub num_rows:      usize,
+    pub num_cols:      usize,
+    pub nonzero_terms: usize,
+}
+
+/// WHIR configurations used by SPARK for each committed polynomial axis.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct SparkWhirConfigs {
+    pub row:                WhirConfig,
+    pub col:                WhirConfig,
+    pub num_terms_2batched: WhirConfig,
+    pub num_terms_5batched: WhirConfig,
+}
+
+/// Verifier-side SPARK setup: WHIR configs, matrix dimensions, the preprocessed
+/// commitment transcript, and the hash config used to seed Fiat-Shamir.
+///
+/// This struct is embedded in [`Verifier`](crate::Verifier) so the SPARK
+/// commitments come from the trusted `.pkv` key rather than an attacker-
+/// supplied setup file.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SparkSetup {
+    pub whir_configs:      SparkWhirConfigs,
+    pub matrix_dimensions: MatrixDimensions,
+    pub transcript:        WhirR1CSProof,
+    pub hash_config:       HashConfig,
+}

provekit/common/src/utils/sumcheck.rs

@@ -152,6 +152,11 @@ fn eval_eq(
     }
 }
 
+/// Evaluates a quadratic polynomial on a value
+pub fn eval_quadratic_poly(poly: [FieldElement; 3], point: FieldElement) -> FieldElement {
+    poly[0] + point * (poly[1] + point * poly[2])
+}
+
 /// Evaluates a cubic polynomial on a value
 pub fn eval_cubic_poly(poly: [FieldElement; 4], point: FieldElement) -> FieldElement {
     poly[0] + point * (poly[1] + point * (poly[2] + point * poly[3]))

provekit/common/src/verifier.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
-        noir_proof_scheme::NoirProofScheme, utils::serde_jsonify, whir_r1cs::WhirR1CSScheme,
-        HashConfig, R1CS,
+        noir_proof_scheme::NoirProofScheme, spark::SparkSetup, utils::serde_jsonify,
+        whir_r1cs::WhirR1CSScheme, HashConfig, R1CS,
     },
     noirc_abi::Abi,
     serde::{Deserialize, Serialize},
@@ -11,13 +11,15 @@ use {
 /// serialized to a `.pkv` file by `prepare` and loaded by `verify` (or by
 /// `generate-gnark-inputs` for the recursive path).
 ///
-/// Holds the R1CS, the WHIR-for-witness commitment configuration, and the
-/// ABI needed to bind public inputs back to their Noir-level names.
+/// Holds the R1CS, the WHIR-for-witness commitment configuration, the SPARK
+/// setup (when `prepare --spark` was used), and the ABI needed to bind public
+/// inputs back to their Noir-level names.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Verifier {
     pub hash_config:      HashConfig,
     pub r1cs:             R1CS,
     pub whir_for_witness: Option<WhirR1CSScheme>,
+    pub spark_setup:      Option<SparkSetup>,
     #[serde(with = "serde_jsonify")]
     pub abi:              Abi,
 }
@@ -28,12 +30,14 @@ impl Verifier {
             NoirProofScheme::Noir(d) => Self {
                 r1cs:             d.r1cs,
                 whir_for_witness: Some(d.whir_for_witness),
+                spark_setup:      None,
                 abi:              d.witness_generator.abi.clone(),
                 hash_config:      d.hash_config,
             },
             NoirProofScheme::Mavros(d) => Self {
                 r1cs:             d.r1cs,
                 whir_for_witness: Some(d.whir_for_witness),
+                spark_setup:      None,
                 abi:              d.abi.clone(),
                 hash_config:      d.hash_config,
             },