[develop] Add o1js-stub to Mina repo in place of SnarkyJS

src/lib/crypto/kimchi/wasm/src/pasta_fp_plonk_index.rs

@@ -43,10 +43,8 @@ pub struct WasmPastaFpLookupTable {
 // below.
 impl From<WasmPastaFpLookupTable> for LookupTable<Fp> {
     fn from(wasm_lt: WasmPastaFpLookupTable) -> LookupTable<Fp> {
-        LookupTable {
-            id: wasm_lt.id.into(),
-            data: wasm_lt.data.0,
-        }
+        LookupTable::create(wasm_lt.id.into(), wasm_lt.data.0)
+            .expect("LookupTable -> WasmPastaFpLookupTable conversion must succeed")
     }
 }
 
@@ -190,36 +188,6 @@ pub fn caml_pasta_fp_plonk_index_domain_d8_size(index: &WasmPastaFpPlonkIndex) -
     index.0.cs.domain.d8.size() as i32
 }
 
-#[wasm_bindgen]
-pub fn caml_pasta_fp_plonk_index_decode(
-    bytes: &[u8],
-    srs: &WasmSrs,
-) -> Result<WasmPastaFpPlonkIndex, JsError> {
-    let mut deserializer = rmp_serde::Deserializer::new(bytes);
-    let mut index =
-        ProverIndex::<GAffine, OpeningProof<GAffine>>::deserialize(&mut deserializer)
-            .map_err(|e| JsError::new(&format!("caml_pasta_fp_plonk_index_decode: {}", e)))?;
-
-    index.srs = srs.0.clone();
-    let (linearization, powers_of_alpha) =
-        expr_linearization(Some(&index.cs.feature_flags), true, 3);
-    index.linearization = linearization;
-    index.powers_of_alpha = powers_of_alpha;
-
-    Ok(WasmPastaFpPlonkIndex(Box::new(index)))
-}
-
-#[wasm_bindgen]
-pub fn caml_pasta_fp_plonk_index_encode(index: &WasmPastaFpPlonkIndex) -> Result<Vec<u8>, JsError> {
-    let mut buffer = Vec::new();
-    let mut serializer = rmp_serde::Serializer::new(&mut buffer);
-    index
-        .0
-        .serialize(&mut serializer)
-        .map_err(|e| JsError::new(&format!("caml_pasta_fp_plonk_index_encode: {}", e)))?;
-    Ok(buffer)
-}
-
 #[wasm_bindgen]
 pub fn caml_pasta_fp_plonk_index_read(
     offset: Option<i32>,
@@ -245,7 +213,7 @@ pub fn caml_pasta_fp_plonk_index_read(
     )
     .map_err(|err| JsValue::from_str(&format!("caml_pasta_fp_plonk_index_read: {err}")))?;
     t.srs = srs.0.clone();
-    let (linearization, powers_of_alpha) = expr_linearization(Some(&t.cs.feature_flags), true, 3);
+    let (linearization, powers_of_alpha) = expr_linearization(Some(&t.cs.feature_flags), true);
     t.linearization = linearization;
     t.powers_of_alpha = powers_of_alpha;
 

src/lib/crypto/kimchi/wasm/src/pasta_fq_plonk_index.rs

@@ -40,10 +40,8 @@ pub struct WasmPastaFqLookupTable {
 
 impl From<WasmPastaFqLookupTable> for LookupTable<Fq> {
     fn from(wasm_lt: WasmPastaFqLookupTable) -> LookupTable<Fq> {
-        LookupTable {
-            id: wasm_lt.id.into(),
-            data: wasm_lt.data.0,
-        }
+        LookupTable::create(wasm_lt.id.into(), wasm_lt.data.0)
+            .expect("LookupTable -> WasmPastaFqLookupTable conversion must succeed")
     }
 }
 
@@ -189,36 +187,6 @@ pub fn caml_pasta_fq_plonk_index_domain_d8_size(index: &WasmPastaFqPlonkIndex) -
     index.0.cs.domain.d8.size() as i32
 }
 
-#[wasm_bindgen]
-pub fn caml_pasta_fq_plonk_index_decode(
-    bytes: &[u8],
-    srs: &WasmSrs,
-) -> Result<WasmPastaFqPlonkIndex, JsError> {
-    let mut deserializer = rmp_serde::Deserializer::new(bytes);
-    let mut index =
-        ProverIndex::<GAffine, OpeningProof<GAffine>>::deserialize(&mut deserializer)
-            .map_err(|e| JsError::new(&format!("caml_pasta_fq_plonk_index_decode: {}", e)))?;
-
-    index.srs = srs.0.clone();
-    let (linearization, powers_of_alpha) =
-        expr_linearization(Some(&index.cs.feature_flags), true, 3);
-    index.linearization = linearization;
-    index.powers_of_alpha = powers_of_alpha;
-
-    Ok(WasmPastaFqPlonkIndex(Box::new(index)))
-}
-
-#[wasm_bindgen]
-pub fn caml_pasta_fq_plonk_index_encode(index: &WasmPastaFqPlonkIndex) -> Result<Vec<u8>, JsError> {
-    let mut buffer = Vec::new();
-    let mut serializer = rmp_serde::Serializer::new(&mut buffer);
-    index
-        .0
-        .serialize(&mut serializer)
-        .map_err(|e| JsError::new(&format!("caml_pasta_fq_plonk_index_encode: {}", e)))?;
-    Ok(buffer)
-}
-
 #[wasm_bindgen]
 pub fn caml_pasta_fq_plonk_index_read(
     offset: Option<i32>,
@@ -244,7 +212,7 @@ pub fn caml_pasta_fq_plonk_index_read(
     )
     .map_err(|err| JsValue::from_str(&format!("caml_pasta_fq_plonk_index_read: {err}")))?;
     t.srs = srs.0.clone();
-    let (linearization, powers_of_alpha) = expr_linearization(Some(&t.cs.feature_flags), true, 3);
+    let (linearization, powers_of_alpha) = expr_linearization(Some(&t.cs.feature_flags), true);
     t.linearization = linearization;
     t.powers_of_alpha = powers_of_alpha;
 

src/lib/crypto/kimchi/wasm/src/plonk_verifier_index.rs

@@ -576,6 +576,7 @@ macro_rules! impl_verification_key {
                 pub shifts: WasmShifts,
                 #[wasm_bindgen(skip)]
                 pub lookup_index: Option<WasmLookupVerifierIndex>,
+                pub zk_rows: isize,
             }
             type WasmPlonkVerifierIndex = [<Wasm $field_name:camel PlonkVerifierIndex>];
 
@@ -591,6 +592,7 @@ macro_rules! impl_verification_key {
                     evals: &WasmPlonkVerificationEvals,
                     shifts: &WasmShifts,
                     lookup_index: Option<WasmLookupVerifierIndex>,
+                    zk_rows: isize,
                 ) -> Self {
                     WasmPlonkVerifierIndex {
                         domain: domain.clone(),
@@ -601,6 +603,7 @@ macro_rules! impl_verification_key {
                         evals: evals.clone(),
                         shifts: shifts.clone(),
                         lookup_index: lookup_index.clone(),
+                        zk_rows: zk_rows,
                     }
                 }
 
@@ -675,6 +678,7 @@ macro_rules! impl_verification_key {
                             s6: vi.shift[6].into(),
                         },
                     lookup_index: vi.lookup_index.map(Into::into),
+                    zk_rows: vi.zk_rows as isize,
                 }
             }
 
@@ -713,54 +717,17 @@ macro_rules! impl_verification_key {
                 }
             } */
 
-            fn compute_feature_flags(index: &WasmPlonkVerifierIndex) -> FeatureFlags {
-                let xor = index.evals.xor_comm.is_some();
-                let range_check0 = index.evals.range_check0_comm.is_some();
-                let range_check1 = index.evals.range_check1_comm.is_some();
-                let foreign_field_add = index.evals.foreign_field_add_comm.is_some();
-                let foreign_field_mul = index.evals.foreign_field_mul_comm.is_some();
-                let rot = index.evals.rot_comm.is_some();
-
-                let lookup = index
-                    .lookup_index.as_ref()
-                    .map_or(false, |li| li.lookup_info.features.patterns.lookup);
-
-                // TODO
-                let runtime_tables = false;
-
-                let patterns = LookupPatterns {
-                    xor,
-                    lookup,
-                    range_check: range_check0 || range_check1 || rot,
-                    foreign_field_mul: foreign_field_mul,
-                };
-
-                FeatureFlags {
-                    range_check0,
-                    range_check1,
-                    foreign_field_add,
-                    foreign_field_mul,
-                    xor,
-                    rot,
-                    lookup_features: LookupFeatures {
-                        patterns,
-                        joint_lookup_used: patterns.joint_lookups_used(),
-                        uses_runtime_tables: runtime_tables,
-                    },
-                }
-            }
-
             pub fn of_wasm(
-                index: WasmPlonkVerifierIndex,
+                max_poly_size: i32,
+                public_: i32,
+                prev_challenges: i32,
+                log_size_of_group: i32,
+                srs: &$WasmSrs,
+                evals: &WasmPlonkVerificationEvals,
+                shifts: &WasmShifts,
+                lookup_index: Option<WasmLookupVerifierIndex>,
+                zk_rows: isize,
             ) -> (DlogVerifierIndex<GAffine, OpeningProof<GAffine>>, Arc<SRS<GAffine>>) {
-                let max_poly_size = index.max_poly_size;
-                let public_ = index.public_;
-                let prev_challenges = index.prev_challenges;
-                let log_size_of_group = index.domain.log_size_of_group;
-                let srs = &index.srs;
-                let evals = &index.evals;
-                let shifts = &index.shifts;
-
                 /*
                 let urs_copy = Rc::clone(&*urs);
                 let urs_copy_outer = Rc::clone(&*urs);
@@ -772,8 +739,27 @@ macro_rules! impl_verification_key {
                 let (endo_q, _endo_r) = poly_commitment::srs::endos::<$GOther>();
                 let domain = Domain::<$F>::new(1 << log_size_of_group).unwrap();
 
-                let feature_flags = compute_feature_flags(&index);
-                let (linearization, powers_of_alpha) = expr_linearization(Some(&feature_flags), true, 3);
+                let feature_flags =
+                    FeatureFlags {
+                        range_check0: false,
+                        range_check1: false,
+                        foreign_field_add: false,
+                        foreign_field_mul: false,
+                        rot: false,
+                        xor: false,
+                        lookup_features:
+                        LookupFeatures {
+                            patterns: LookupPatterns {
+                                xor: false,
+                                lookup: false,
+                                range_check: false,
+                                foreign_field_mul: false, },
+                            joint_lookup_used:false,
+                            uses_runtime_tables: false,
+                        },
+                    };
+
+                let (linearization, powers_of_alpha) = expr_linearization(Some(&feature_flags), true);
 
                 let index =
                     DlogVerifierIndex {
@@ -824,18 +810,29 @@ macro_rules! impl_verification_key {
                           Arc::clone(&srs.0)
                         },
 
-                        zk_rows: 3,
+                        zk_rows: zk_rows as u64,
 
                         linearization,
                         powers_of_alpha,
-                        lookup_index: index.lookup_index.map(Into::into),
+                        lookup_index: lookup_index.map(Into::into),
                     };
                 (index, srs.0.clone())
             }
 
             impl From<WasmPlonkVerifierIndex> for DlogVerifierIndex<$G, OpeningProof<$G>> {
                 fn from(index: WasmPlonkVerifierIndex) -> Self {
-                    of_wasm(index).0
+                    of_wasm(
+                        index.max_poly_size,
+                        index.public_,
+                        index.prev_challenges,
+                        index.domain.log_size_of_group,
+                        &index.srs,
+                        &index.evals,
+                        &index.shifts,
+                        index.lookup_index,
+                        index.zk_rows
+                    )
+                    .0
                 }
             }
 
@@ -910,12 +907,9 @@ macro_rules! impl_verification_key {
             pub fn [<$name:snake _deserialize>](
                 srs: &$WasmSrs,
                 index: String,
-            ) -> Result<WasmPlonkVerifierIndex, JsError> {
-                let vi: Result<DlogVerifierIndex<$G, OpeningProof<$G>>, serde_json::Error> = serde_json::from_str(&index);
-                match vi {
-                    Ok(vi) => Ok(to_wasm(srs, vi)),
-                    Err(e) => Err(JsError::new(&(e.to_string()))),
-                }
+            ) -> WasmPlonkVerifierIndex {
+                let vi: DlogVerifierIndex<$G, OpeningProof<$G>> = serde_json::from_str(&index).unwrap();
+                return to_wasm(srs, vi.into())
             }
 
             #[wasm_bindgen]
@@ -995,7 +989,8 @@ macro_rules! impl_verification_key {
                             s5: $F::one().into(),
                             s6: $F::one().into(),
                         },
-                    lookup_index: None
+                    lookup_index: None,
+                    zk_rows: 3,
                 }
             }