(proof-systems) Native Prover with Napi - Proof

plonk-napi/Cargo.toml

@@ -26,9 +26,10 @@ arkworks.workspace = true
 mina-curves = { path = "../curves" }
 mina-poseidon = { path = "../poseidon" }
 o1-utils = { path = "../utils" }
-poly-commitment = { path = "../poly-commitment" }
 plonk_wasm.workspace = true
+poly-commitment = { path = "../poly-commitment" }
 
+base64.workspace = true
 getrandom.workspace = true
 kimchi.workspace = true
 libc.workspace = true

plonk-napi/src/lib.rs

@@ -1,6 +1,7 @@
 mod build_info;
 mod circuit;
 mod gate_vector;
+mod oracles;
 mod pasta_fp_plonk_index;
 mod pasta_fq_plonk_index;
 mod plonk_verifier_index;
@@ -30,32 +31,71 @@ pub use gate_vector::{
     NapiFpGateVector as WasmFpGateVector, NapiFqGate as WasmFqGate,
     NapiFqGateVector as WasmFqGateVector,
 };
+pub use oracles::{
+    fp::{fp_oracles_create, fp_oracles_deep_copy, fp_oracles_dummy},
+    fq::{fq_oracles_create, fq_oracles_deep_copy, fq_oracles_dummy},
+};
 pub use pasta_fp_plonk_index::{
-    prover_index_fp_from_bytes, prover_index_fp_to_bytes, WasmPastaFpPlonkIndex,
+    caml_pasta_fp_plonk_index_create, caml_pasta_fp_plonk_index_decode,
+    caml_pasta_fp_plonk_index_domain_d1_size, caml_pasta_fp_plonk_index_domain_d4_size,
+    caml_pasta_fp_plonk_index_domain_d8_size, caml_pasta_fp_plonk_index_encode,
+    caml_pasta_fp_plonk_index_max_degree, caml_pasta_fp_plonk_index_public_inputs,
+    caml_pasta_fp_plonk_index_read, caml_pasta_fp_plonk_index_write, prover_index_fp_deserialize,
+    prover_index_fp_serialize, WasmPastaFpPlonkIndex,
 };
 pub use pasta_fq_plonk_index::{
-    prover_index_fq_from_bytes, prover_index_fq_to_bytes, WasmPastaFqPlonkIndex,
+    caml_pasta_fq_plonk_index_create, caml_pasta_fq_plonk_index_decode,
+    caml_pasta_fq_plonk_index_domain_d1_size, caml_pasta_fq_plonk_index_domain_d4_size,
+    caml_pasta_fq_plonk_index_domain_d8_size, caml_pasta_fq_plonk_index_encode,
+    caml_pasta_fq_plonk_index_max_degree, caml_pasta_fq_plonk_index_public_inputs,
+    caml_pasta_fq_plonk_index_read, caml_pasta_fq_plonk_index_write, prover_index_fq_deserialize,
+    prover_index_fq_serialize, WasmPastaFqPlonkIndex,
 };
 pub use plonk_verifier_index::{
-    caml_pasta_fp_plonk_verifier_index_shifts, caml_pasta_fq_plonk_verifier_index_shifts,
+    fp::{
+        caml_pasta_fp_plonk_verifier_index_create, caml_pasta_fp_plonk_verifier_index_deep_copy,
+        caml_pasta_fp_plonk_verifier_index_deserialize, caml_pasta_fp_plonk_verifier_index_dummy,
+        caml_pasta_fp_plonk_verifier_index_read, caml_pasta_fp_plonk_verifier_index_serialize,
+        caml_pasta_fp_plonk_verifier_index_shifts, caml_pasta_fp_plonk_verifier_index_write,
+        NapiFpLookupVerifierIndex, NapiFpPlonkVerifierIndex,
+    },
+    fq::{
+        caml_pasta_fq_plonk_verifier_index_create, caml_pasta_fq_plonk_verifier_index_deep_copy,
+        caml_pasta_fq_plonk_verifier_index_deserialize, caml_pasta_fq_plonk_verifier_index_dummy,
+        caml_pasta_fq_plonk_verifier_index_read, caml_pasta_fq_plonk_verifier_index_serialize,
+        caml_pasta_fq_plonk_verifier_index_shifts, caml_pasta_fq_plonk_verifier_index_write,
+        NapiFqLookupVerifierIndex, NapiFqPlonkVerifierIndex,
+    },
 };
+
 pub use poly_comm::{
     pallas::NapiFqPolyComm as WasmFqPolyComm, vesta::NapiFpPolyComm as WasmFpPolyComm,
 };
 pub use poseidon::{caml_pasta_fp_poseidon_block_cipher, caml_pasta_fq_poseidon_block_cipher};
-pub use proof::caml_pasta_fp_plonk_proof_create;
+pub use proof::{
+    fp::{
+        caml_pasta_fp_plonk_proof_batch_verify, caml_pasta_fp_plonk_proof_create,
+        caml_pasta_fp_plonk_proof_deep_copy, caml_pasta_fp_plonk_proof_dummy,
+        caml_pasta_fp_plonk_proof_verify, NapiFpLookupCommitments, NapiFpOpeningProof,
+        NapiFpProofEvaluations, NapiFpProverCommitments, NapiFpProverProof,
+    },
+    fq::{
+        caml_pasta_fq_plonk_proof_batch_verify, caml_pasta_fq_plonk_proof_create,
+        caml_pasta_fq_plonk_proof_deep_copy, caml_pasta_fq_plonk_proof_dummy,
+        caml_pasta_fq_plonk_proof_verify, NapiFqLookupCommitments, NapiFqOpeningProof,
+        NapiFqProofEvaluations, NapiFqProverCommitments, NapiFqProverProof,
+    },
+};
 pub use srs::{
     caml_fp_srs_from_bytes, caml_fp_srs_from_bytes_external, caml_fp_srs_to_bytes,
-    caml_fq_srs_from_bytes, caml_fq_srs_from_bytes_external, caml_fq_srs_to_bytes,
-    fp::NapiFpSrs as WasmFpSrs, fq::NapiFqSrs as WasmFqSrs, *,
+    caml_fp_srs_to_bytes_external, caml_fq_srs_from_bytes, caml_fq_srs_from_bytes_external,
+    caml_fq_srs_to_bytes, caml_fq_srs_to_bytes_external, fp::NapiFpSrs as WasmFpSrs,
+    fq::NapiFqSrs as WasmFqSrs, *,
 };
 pub use tables::{JsLookupTableFp, JsLookupTableFq, JsRuntimeTableCfgFp, JsRuntimeTableCfgFq};
-pub use vector::{
-    fp::NapiVecVecFp as WasmVecVecFp, fq::NapiVecVecFq as WasmVecVecFq, NapiFlatVector,
-};
+pub use vector::{fp::WasmVecVecFp, fq::WasmVecVecFq, NapiFlatVector};
 pub use wrappers::{
     field::{NapiPastaFp as WasmPastaFp, NapiPastaFq as WasmPastaFq},
     group::{NapiGPallas as WasmGPallas, NapiGVesta as WasmGVesta},
+    lookups::{NapiFpRuntimeTable, NapiFqRuntimeTable},
 };
-
-pub use plonk_verifier_index::{fp::*, fq::*};

plonk-napi/src/plonk_verifier_index/fp.rs → plonk-napi/src/old_plonk_verifier_index/fp.rs

@@ -2,6 +2,7 @@ use crate::{
     poly_comm::vesta::NapiFpPolyComm,
     srs::fp::NapiFpSrs,
     wrappers::{field::NapiPastaFp, lookups::NapiLookupInfo},
+    WasmPastaFpPlonkIndex,
 };
 use ark_poly::{EvaluationDomain, Radix2EvaluationDomain as Domain};
 use kimchi::{
@@ -16,15 +17,12 @@ use kimchi::{
         },
     },
     linearization::expr_linearization,
-    verifier_index::{LookupVerifierIndex, VerifierIndex as DlogVerifierIndex},
+    verifier_index::{LookupVerifierIndex, VerifierIndex},
 };
 use mina_curves::pasta::{Fp, Pallas as GAffineOther, Vesta as GAffine};
-use napi::bindgen_prelude::{Error, Status};
+use napi::bindgen_prelude::{Error, External, Status};
 use napi_derive::napi;
-use poly_commitment::{
-    commitment::PolyComm,
-    ipa::{OpeningProof, SRS},
-};
+use poly_commitment::{commitment::PolyComm, ipa::OpeningProof, SRS};
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
@@ -35,6 +33,22 @@ pub struct NapiFpDomain {
     pub group_gen: NapiPastaFp,
 }
 
+impl From<NapiFpDomain> for Domain<Fp> {
+    fn from(domain: NapiFpDomain) -> Self {
+        let size = 1 << domain.log_size_of_group;
+        Domain::<Fp>::new(size).expect("Failed to create evaluation domain")
+    }
+}
+
+impl From<&Domain<Fp>> for NapiFpDomain {
+    fn from(domain: &Domain<Fp>) -> Self {
+        Self {
+            log_size_of_group: domain.log_size_of_group as i32,
+            group_gen: domain.group_gen.into(),
+        }
+    }
+}
+
 #[napi(object, js_name = "WasmFpShifts")]
 #[derive(Clone, Debug, Serialize, Deserialize, Default)]
 pub struct NapiFpShifts {
@@ -47,6 +61,20 @@ pub struct NapiFpShifts {
     pub s6: NapiPastaFp,
 }
 
+impl From<&[Fp; 7]> for NapiFpShifts {
+    fn from(shifts: &[Fp; 7]) -> Self {
+        Self {
+            s0: shifts[0].into(),
+            s1: shifts[1].into(),
+            s2: shifts[2].into(),
+            s3: shifts[3].into(),
+            s4: shifts[4].into(),
+            s5: shifts[5].into(),
+            s6: shifts[6].into(),
+        }
+    }
+}
+
 #[napi(object, js_name = "WasmFpLookupSelectors")]
 #[derive(Clone, Debug, Serialize, Deserialize, Default)]
 pub struct NapiFpLookupSelectors {
@@ -182,6 +210,27 @@ pub struct NapiFpPlonkVerificationEvals {
     pub rot_comm: Option<NapiFpPolyComm>,
 }
 
+impl From<&VerifierIndex<GAffine, OpeningProof<GAffine>>> for NapiFpPlonkVerificationEvals {
+    fn from(index: &VerifierIndex<GAffine, OpeningProof<GAffine>>) -> Self {
+        Self {
+            sigma_comm: index.sigma_comm.iter().map(Into::into).collect(),
+            coefficients_comm: index.coefficients_comm.iter().map(Into::into).collect(),
+            generic_comm: index.generic_comm.clone().into(),
+            psm_comm: index.psm_comm.clone().into(),
+            complete_add_comm: index.complete_add_comm.clone().into(),
+            mul_comm: index.mul_comm.clone().into(),
+            emul_comm: index.emul_comm.clone().into(),
+            endomul_scalar_comm: index.endomul_scalar_comm.clone().into(),
+            xor_comm: index.xor_comm.clone().map(Into::into),
+            range_check0_comm: index.range_check0_comm.clone().map(Into::into),
+            range_check1_comm: index.range_check1_comm.clone().map(Into::into),
+            foreign_field_add_comm: index.foreign_field_add_comm.clone().map(Into::into),
+            foreign_field_mul_comm: index.foreign_field_mul_comm.clone().map(Into::into),
+            rot_comm: index.rot_comm.clone().map(Into::into),
+        }
+    }
+}
+
 #[napi(object, js_name = "WasmFpPlonkVerifierIndex")]
 #[derive(Clone, Debug, Default)]
 pub struct NapiFpPlonkVerifierIndex {
@@ -196,6 +245,28 @@ pub struct NapiFpPlonkVerifierIndex {
     pub zk_rows: i32,
 }
 
+#[napi(js_name = "caml_pasta_fp_plonk_verifier_index_create")]
+pub fn caml_pasta_fp_plonk_verifier_index_create(
+    index: &External<WasmPastaFpPlonkIndex>,
+) -> NapiFpPlonkVerifierIndex {
+    index
+        .0
+        .srs
+        .get_lagrange_basis(index.0.as_ref().cs.domain.d1);
+    let verifier_index = index.0.as_ref().verifier_index();
+    NapiFpPlonkVerifierIndex::from(&verifier_index)
+}
+
+#[napi(js_name = "caml_pasta_fp_plonk_verifier_index_read")]
+pub fn caml_pasta_fp_plonk_verifier_index_read(
+    offset: Option<i32>,
+    srs: &External<NapiFpSrs>,
+    path: String,
+) -> NapiFpPlonkVerifierIndex {
+    let vi = read_raw(offset, srs, path)?;
+    Ok(to_wasm(srs, vi.into()))
+}
+
 #[napi(js_name = "caml_pasta_fp_plonk_verifier_index_shifts")]
 pub fn caml_pasta_fp_plonk_verifier_index_shifts(
     log2_size: i32,
@@ -223,7 +294,7 @@ pub fn caml_pasta_fp_plonk_verifier_index_shifts(
     })
 }
 
-impl From<NapiFpPlonkVerifierIndex> for DlogVerifierIndex<GAffine, OpeningProof<GAffine>> {
+impl From<NapiFpPlonkVerifierIndex> for VerifierIndex<GAffine, OpeningProof<GAffine>> {
     fn from(index: NapiFpPlonkVerifierIndex) -> Self {
         let max_poly_size = index.max_poly_size;
         let public_ = index.public_;
@@ -242,7 +313,7 @@ impl From<NapiFpPlonkVerifierIndex> for DlogVerifierIndex<GAffine, OpeningProof<
         let index = {
             let zk_rows = index.zk_rows as u64;
 
-            DlogVerifierIndex {
+            VerifierIndex {
                 domain,
 
                 sigma_comm: core::array::from_fn(|i| (&evals.sigma_comm[i]).into()),
@@ -300,6 +371,22 @@ impl From<NapiFpPlonkVerifierIndex> for DlogVerifierIndex<GAffine, OpeningProof<
     }
 }
 
+impl From<&VerifierIndex<GAffine, OpeningProof<GAffine>>> for NapiFpPlonkVerifierIndex {
+    fn from(index: &VerifierIndex<GAffine, OpeningProof<GAffine>>) -> Self {
+        Self {
+            domain: (&index.domain).into(),
+            max_poly_size: index.max_poly_size as i32,
+            public_: index.public as i32,
+            prev_challenges: index.prev_challenges as i32,
+            srs: (&index.srs).into(),
+            evals: index.into(),
+            shifts: (&index.shift).into(),
+            lookup_index: index.lookup_index.as_ref().map(Into::into),
+            zk_rows: index.zk_rows as i32,
+        }
+    }
+}
+
 fn compute_feature_flags(index: &NapiFpPlonkVerifierIndex) -> FeatureFlags {
     let xor = index.evals.xor_comm.is_some();
     let range_check0 = index.evals.range_check0_comm.is_some();