Merge pull request #179 from o1-labs/feature/range-check-64-develop

Activate custom gates in JS and add rangeCheck64 gadget

js/snarky-class-spec.js

@@ -12,6 +12,10 @@ export default [
         name: 'field',
         type: 'object',
       },
+      {
+        name: 'gates',
+        type: 'object',
+      },
       {
         name: 'bool',
         type: 'object',

kimchi/wasm/src/plonk_verifier_index.rs

@@ -713,16 +713,54 @@ 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(
-                max_poly_size: i32,
-                public_: i32,
-                prev_challenges: i32,
-                log_size_of_group: i32,
-                srs: &$WasmSrs,
-                evals: &WasmPlonkVerificationEvals,
-                shifts: &WasmShifts,
-                lookup_index: Option<WasmLookupVerifierIndex>
+                index: WasmPlonkVerifierIndex,
             ) -> (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);
@@ -734,26 +772,7 @@ 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 =
-                    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 feature_flags = compute_feature_flags(&index);
                 let (linearization, powers_of_alpha) = expr_linearization(Some(&feature_flags), true, 3);
 
                 let index =
@@ -809,24 +828,14 @@ macro_rules! impl_verification_key {
 
                         linearization,
                         powers_of_alpha,
-                        lookup_index: lookup_index.map(Into::into),
+                        lookup_index: 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.max_poly_size,
-                        index.public_,
-                        index.prev_challenges,
-                        index.domain.log_size_of_group,
-                        &index.srs,
-                        &index.evals,
-                        &index.shifts,
-                        index.lookup_index
-                    )
-                    .0
+                    of_wasm(index).0
                 }
             }
 

ocaml/lib/pickles_bindings.ml

@@ -68,6 +68,7 @@ type pickles_rule_js =
           ; shouldVerify : Boolean.var array Js.prop >
           Js.t )
       Js.prop
+  ; featureFlags : bool Pickles_types.Plonk_types.Features.t Js.prop
   ; proofsToVerify :
       < isSelf : bool Js.t Js.prop ; tag : Js.Unsafe.any Js.t Js.prop > Js.t
       array
@@ -250,7 +251,7 @@ module Choices = struct
                 Pickles.Tag.t ) ->
           let prevs = prevs ~self in
           { Pickles.Inductive_rule.identifier = Js.to_string rule##.identifier
-          ; feature_flags = Pickles_types.Plonk_types.Features.none_bool
+          ; feature_flags = rule##.featureFlags
           ; prevs
           ; main =
               (fun { public_input } ->

ocaml/lib/pickles_bindings.mli

@@ -30,6 +30,7 @@ type pickles_rule_js =
           ; shouldVerify : Boolean.var array Js.prop >
           Js.t )
       Js.prop
+  ; featureFlags : bool Pickles_types.Plonk_types.Features.t Js.prop
   ; proofsToVerify :
       < isSelf : bool Js.t Js.prop ; tag : Js.Unsafe.any Js.t Js.prop > Js.t
       array

ocaml/lib/snarky_bindings.ml

@@ -113,6 +113,36 @@ module Field' = struct
   let to_constant_and_terms x = Field.to_constant_and_terms x
 end
 
+module Gates = struct
+  let range_check0 v0 (v0p0, v0p1, v0p2, v0p3, v0p4, v0p5)
+      (v0c0, v0c1, v0c2, v0c3, v0c4, v0c5, v0c6, v0c7) compact =
+    Impl.with_label "range_check0" (fun () ->
+        Impl.assert_
+          { annotation = Some __LOC__
+          ; basic =
+              Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T
+                (RangeCheck0
+                   { (* Current row *) v0
+                   ; v0p0
+                   ; v0p1
+                   ; v0p2
+                   ; v0p3
+                   ; v0p4
+                   ; v0p5
+                   ; v0c0
+                   ; v0c1
+                   ; v0c2
+                   ; v0c3
+                   ; v0c4
+                   ; v0c5
+                   ; v0c6
+                   ; v0c7
+                   ; (* Coefficients *)
+                     compact
+                   } )
+          } )
+end
+
 module Bool = struct
   let not x = Boolean.not x
 
@@ -284,6 +314,11 @@ let snarky =
         method toConstantAndTerms = to_constant_and_terms
       end
 
+    val gates =
+      object%js
+        method rangeCheck0 = Gates.range_check0
+      end
+
     val bool =
       object%js
         method not = Bool.not