Merge pull request #3345 from o1-labs/florian/napi-prover-json

[DO NOT MERGE] native `circuit.rs` implementation

Author: querolita

Cargo.lock

@@ -23,9 +23,11 @@ ark-serialize.workspace = true
 arkworks.workspace = true
 
 # proof-systems
+kimchi.workspace = true
 mina-curves = { path = "../curves" }
 mina-poseidon = { path = "../poseidon" }
 o1-utils = { path = "../utils" }
+poly-commitment = { path = "../poly-commitment" }
 
 getrandom.workspace = true
 libc.workspace = true
@@ -36,6 +38,7 @@ rand.workspace = true
 rayon.workspace = true
 rmp-serde.workspace = true
 serde.workspace = true
+serde_json.workspace = true
 serde_with.workspace = true
 wasm-types.workspace = true
 

plonk-napi/Cargo.toml

@@ -0,0 +1,36 @@
+use ark_ff::PrimeField;
+use kimchi::circuits::{constraints::ConstraintSystem, gate::CircuitGate};
+use mina_curves::pasta::Fp;
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use serde::Serialize;
+
+use crate::types::WasmPastaFpPlonkIndex;
+
+#[derive(Serialize)]
+struct Circuit<F>
+where
+    F: PrimeField,
+{
+    public_input_size: usize,
+    #[serde(bound = "CircuitGate<F>: Serialize")]
+    gates: Vec<CircuitGate<F>>,
+}
+
+impl<F> From<&ConstraintSystem<F>> for Circuit<F>
+where
+    F: PrimeField,
+{
+    fn from(cs: &ConstraintSystem<F>) -> Self {
+        Self {
+            public_input_size: cs.public,
+            gates: cs.gates.to_vec(),
+        }
+    }
+}
+
+#[napi]
+pub fn prover_to_json(prover_index: External<WasmPastaFpPlonkIndex>) -> String {
+    let circuit: Circuit<Fp> = prover_index.0.cs.as_ref().into();
+    serde_json::to_string(&circuit).expect("couldn't serialize constraints")
+}

plonk-napi/src/circuit.rs

@@ -1,6 +1,8 @@
+mod circuit;
 mod poseidon;
+mod types;
 
-pub use poseidon::{
-    caml_pasta_fp_poseidon_block_cipher,
-    caml_pasta_fq_poseidon_block_cipher,
-};
+pub use poseidon::{caml_pasta_fp_poseidon_block_cipher, caml_pasta_fq_poseidon_block_cipher};
+
+pub use circuit::prover_to_json;
+pub use types::{prover_index_from_bytes, prover_index_to_bytes, WasmPastaFpPlonkIndex};

plonk-napi/src/lib.rs

@@ -0,0 +1,79 @@
+use kimchi::{linearization::expr_linearization, prover_index::ProverIndex};
+use mina_curves::pasta::{Vesta as GAffine, VestaParameters};
+use mina_poseidon::{constants::PlonkSpongeConstantsKimchi, sponge::DefaultFqSponge};
+use napi::bindgen_prelude::{Error, External, Result as NapiResult, Status, Uint8Array};
+use napi_derive::napi;
+use poly_commitment::ipa::{OpeningProof, SRS};
+use serde::{Deserialize, Serialize};
+use std::{io::Cursor, sync::Arc};
+
+pub struct WasmPastaFpPlonkIndex(pub Box<ProverIndex<GAffine, OpeningProof<GAffine>>>);
+
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+#[derive(Serialize, Deserialize)]
+struct SerializedProverIndex {
+    prover_index: Vec<u8>,
+    srs: Vec<u8>,
+}
+
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+impl WasmPastaFpPlonkIndex {
+    fn serialize_inner(&self) -> Result<Vec<u8>, String> {
+        let prover_index = rmp_serde::to_vec(self.0.as_ref()).map_err(|e| e.to_string())?;
+
+        let mut srs = Vec::new();
+        self.0
+            .srs
+            .serialize(&mut rmp_serde::Serializer::new(&mut srs))
+            .map_err(|e| e.to_string())?;
+
+        let serialized = SerializedProverIndex { prover_index, srs };
+
+        rmp_serde::to_vec(&serialized).map_err(|e| e.to_string())
+    }
+
+    fn deserialize_inner(bytes: &[u8]) -> Result<Self, String> {
+        let serialized: SerializedProverIndex =
+            rmp_serde::from_slice(bytes).map_err(|e| e.to_string())?;
+
+        let mut index: ProverIndex<GAffine, OpeningProof<GAffine>> = ProverIndex::deserialize(
+            &mut rmp_serde::Deserializer::new(Cursor::new(serialized.prover_index)),
+        )
+        .map_err(|e| e.to_string())?;
+
+        let srs = SRS::<GAffine>::deserialize(&mut rmp_serde::Deserializer::new(Cursor::new(
+            serialized.srs,
+        )))
+        .map_err(|e| e.to_string())?;
+
+        index.srs = Arc::new(srs);
+
+        let (linearization, powers_of_alpha) =
+            expr_linearization(Some(&index.cs.feature_flags), true);
+        index.linearization = linearization;
+        index.powers_of_alpha = powers_of_alpha;
+
+        index.compute_verifier_index_digest::<
+            DefaultFqSponge<VestaParameters, PlonkSpongeConstantsKimchi>,
+        >();
+
+        Ok(WasmPastaFpPlonkIndex(Box::new(index)))
+    }
+}
+
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+#[napi]
+pub fn prover_index_from_bytes(bytes: Uint8Array) -> NapiResult<External<WasmPastaFpPlonkIndex>> {
+    let index = WasmPastaFpPlonkIndex::deserialize_inner(bytes.as_ref())
+        .map_err(|e| Error::new(Status::InvalidArg, e))?;
+    Ok(External::new(index))
+}
+
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+#[napi]
+pub fn prover_index_to_bytes(index: External<WasmPastaFpPlonkIndex>) -> NapiResult<Uint8Array> {
+    let bytes = index
+        .serialize_inner()
+        .map_err(|e| Error::new(Status::GenericFailure, e))?;
+    Ok(Uint8Array::from(bytes))
+}

plonk-napi/src/types.rs

@@ -20,7 +20,8 @@ use mina_poseidon::{constants::PlonkSpongeConstantsKimchi, sponge::DefaultFqSpon
 use serde::{Deserialize, Serialize};
 use std::{
     fs::{File, OpenOptions},
-    io::{BufReader, BufWriter, Seek, SeekFrom::Start},
+    io::{BufReader, BufWriter, Cursor, Seek, SeekFrom::Start},
+    sync::Arc,
 };
 use wasm_bindgen::prelude::*;
 use wasm_types::FlatVector as WasmFlatVector;
@@ -35,6 +36,71 @@ pub struct WasmPastaFpPlonkIndex(
     #[wasm_bindgen(skip)] pub Box<ProverIndex<GAffine, OpeningProof<GAffine>>>,
 );
 
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+#[derive(Serialize, Deserialize)]
+struct SerializedProverIndex {
+    prover_index: Vec<u8>,
+    srs: Vec<u8>,
+}
+
+// TOOD: remove incl all dependencies when no longer needed and we only pass napi objects around
+#[wasm_bindgen]
+impl WasmPastaFpPlonkIndex {
+    #[wasm_bindgen(js_name = "serialize")]
+    pub fn serialize(&self) -> Result<Vec<u8>, JsError> {
+        serialize_prover_index(self.0.as_ref())
+            .map_err(|e| JsError::new(&format!("WasmPastaFpPlonkIndex::serialize: {e}")))
+    }
+
+    #[wasm_bindgen(js_name = "deserialize")]
+    pub fn deserialize(bytes: &[u8]) -> Result<WasmPastaFpPlonkIndex, JsError> {
+        deserialize_prover_index(bytes)
+            .map(WasmPastaFpPlonkIndex)
+            .map_err(|e| JsError::new(&format!("WasmPastaFpPlonkIndex::deserialize: {e}")))
+    }
+}
+
+fn serialize_prover_index(
+    index: &ProverIndex<GAffine, OpeningProof<GAffine>>,
+) -> Result<Vec<u8>, String> {
+    let prover_index = rmp_serde::to_vec(index).map_err(|e| e.to_string())?;
+
+    let mut srs = Vec::new();
+    index
+        .srs
+        .serialize(&mut rmp_serde::Serializer::new(&mut srs))
+        .map_err(|e| e.to_string())?;
+
+    let serialized = SerializedProverIndex { prover_index, srs };
+
+    rmp_serde::to_vec(&serialized).map_err(|e| e.to_string())
+}
+
+fn deserialize_prover_index(
+    bytes: &[u8],
+) -> Result<Box<ProverIndex<GAffine, OpeningProof<GAffine>>>, String> {
+    let serialized: SerializedProverIndex =
+        rmp_serde::from_slice(bytes).map_err(|e| e.to_string())?;
+
+    let mut index: ProverIndex<GAffine, OpeningProof<GAffine>> = ProverIndex::deserialize(
+        &mut rmp_serde::Deserializer::new(Cursor::new(serialized.prover_index)),
+    )
+    .map_err(|e| e.to_string())?;
+
+    let srs = poly_commitment::ipa::SRS::<GAffine>::deserialize(&mut rmp_serde::Deserializer::new(
+        Cursor::new(serialized.srs),
+    ))
+    .map_err(|e| e.to_string())?;
+
+    index.srs = Arc::new(srs);
+
+    let (linearization, powers_of_alpha) = expr_linearization(Some(&index.cs.feature_flags), true);
+    index.linearization = linearization;
+    index.powers_of_alpha = powers_of_alpha;
+
+    Ok(Box::new(index))
+}
+
 // This should mimic LookupTable structure
 #[wasm_bindgen]
 pub struct WasmPastaFpLookupTable {