chore: use bool for ScanData fields (#72)

Author: jialinli98

src/json.nr

@@ -420,27 +420,28 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let mut transcript_ptr: u32 = 0;
         let mut scan_mode = GRAMMAR_CAPTURE;
         let mut length: Field = 0;
-        let mut previous_was_potential_escape_sequence = 0;
+        let mut previous_was_potential_escape_sequence: bool = false;
         for i in 0..NumBytes {
             // while this assert is in an unconstrained function, the out of bounds accesss `raw_transcript[transcript_ptr]` in build_transcript also generates failing constraints
             assert(transcript_ptr < MaxNumTokens, "build_transcript: MaxNumTokens limit exceeded!");
             let ascii = self.json[i];
 
-            let encoded_ascii =
-                previous_was_potential_escape_sequence * 1024 + scan_mode * 256 + ascii as Field;
+            let encoded_ascii = previous_was_potential_escape_sequence as Field * 1024
+                + scan_mode * 256
+                + ascii as Field;
             let ScanData { scan_token, push_transcript, increase_length, is_potential_escape_sequence } =
                 ScanData::from_field(JSON_CAPTURE_TABLE[cast_num_to_u32(encoded_ascii)]);
 
-            if push_transcript == 1 {
+            if push_transcript {
                 let new_entry = RawTranscriptEntry::to_field(
                     RawTranscriptEntry { encoded_ascii, index: i as Field - length, length },
                 );
 
                 raw_transcript[transcript_ptr] = new_entry;
                 transcript_ptr += 1;
-                length = increase_length;
+                length = increase_length as Field;
             } else {
-                length += increase_length;
+                length += increase_length as Field;
             }
 
             previous_was_potential_escape_sequence = is_potential_escape_sequence;
@@ -493,13 +494,14 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let raw_transcript = unsafe { self.__build_transcript() };
 
         // 14 gates per iteration, plus fixed cost for initing 2,048 size lookup table (4,096 gates)
-        let mut previous_was_potential_escape_sequence = 0;
+        let mut previous_was_potential_escape_sequence: bool = false;
         for i in 0..NumBytes {
             let ascii = self.json[i];
 
             // 1 gate
-            let encoded_ascii =
-                previous_was_potential_escape_sequence * 1024 + scan_mode * 256 + ascii as Field;
+            let encoded_ascii = previous_was_potential_escape_sequence as Field * 1024
+                + scan_mode * 256
+                + ascii as Field;
             std::as_witness(encoded_ascii);
 
             // 2 gates
@@ -519,14 +521,14 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
             std::as_witness(diff);
 
             // 1 gate
-            assert(diff * push_transcript == 0);
+            assert(diff * push_transcript as Field == 0);
 
             // 1 gate
-            length = length * (1 - push_transcript) + increase_length;
+            length = length * (1 - push_transcript as Field) + increase_length as Field;
             std::as_witness(length);
 
             // 1 gate
-            transcript_ptr += push_transcript;
+            transcript_ptr += push_transcript as Field;
 
             previous_was_potential_escape_sequence = is_potential_escape_sequence;
             scan_mode = scan_token;

src/transcript_entry.nr

@@ -107,19 +107,19 @@ pub(crate) struct TranscriptEntry {
 
 pub(crate) struct ScanData {
     pub(crate) scan_token: Field,
-    pub(crate) push_transcript: Field,
-    pub(crate) increase_length: Field,
-    pub(crate) is_potential_escape_sequence: Field,
+    pub(crate) push_transcript: bool,
+    pub(crate) increase_length: bool,
+    pub(crate) is_potential_escape_sequence: bool,
 }
 
 impl ScanData {
     unconstrained fn __from_field(f: Field) -> Self {
         let bytes: [u8; 6] = f.to_le_bytes();
 
         let scan_token: Field = bytes[0] as Field;
-        let push_transcript = bytes[1] as Field;
-        let increase_length = bytes[2] as Field;
-        let is_potential_escape_sequence = bytes[3] as Field;
+        let push_transcript = bytes[1] != 0;
+        let increase_length = bytes[2] != 0;
+        let is_potential_escape_sequence = bytes[3] != 0;
         let error = bytes[4] as Field * 0x100 + bytes[5] as Field;
         assert(error == 0, "ScanData: Invalid token");
         ScanData { scan_token, push_transcript, increase_length, is_potential_escape_sequence }
@@ -128,21 +128,12 @@ impl ScanData {
     pub(crate) fn from_field(f: Field) -> Self {
         // Safety: check the comments below
         let result = unsafe { ScanData::__from_field(f) };
-        // checks increase_length is a valid boolean
-        assert(result.increase_length * result.increase_length == result.increase_length);
-        // checks push_transcript is a valid boolean
-        assert(result.push_transcript * result.push_transcript == result.push_transcript);
-        // checks is_potential_escape_sequence is a valid boolean
-        assert(
-            result.is_potential_escape_sequence * result.is_potential_escape_sequence
-                == result.is_potential_escape_sequence,
-        );
         // checks the input field is a valid combination of the outputs of the decomposition
         assert(
             result.scan_token
-                + result.push_transcript * 0x100
-                + result.increase_length * 0x10000
-                + result.is_potential_escape_sequence * 0x1000000
+                + result.push_transcript as Field * 0x100
+                + result.increase_length as Field * 0x10000
+                + result.is_potential_escape_sequence as Field * 0x1000000
                 == f,
         );
         result