wip

Author: zac-williamson

out.txt

@@ -0,0 +1,97 @@
+use crate::getters;
+use dep::noir_sort;
+use crate::json_entry::JSONEntry;
+use crate::redux::JSON;
+use crate::keymap;
+use crate::lt::{lt_field_8_bit, lt_field_16_bit, assert_lt_240_bit, assert_gt_240_bit};
+use crate::redux_tables::{
+    OBJECT_LAYER, ARRAY_LAYER, NUMERIC_TOKEN, LITERAL_TOKEN, STRING_TOKEN, BEGIN_OBJECT_TOKEN,
+    BEGIN_ARRAY_TOKEN, ASCII_TO_NUMBER, ESCAPE_SEQUENCE_END_CHARS, ESCAPE_SEQUENCE_START_CHARS,
+    ESCAPE_SEQUENCE_REPLACEMENT
+};
+use crate::keyhash::Hasher;
+use crate::keyhash::get_keyhash;
+use crate::slice_field::slice_fields;
+use crate::getters::JSONValue;
+
+impl<let NumBytes: u32, let NumPackedFields: u16, let MaxNumTokens: u16, let MaxNumValues: u16> JSON<NumBytes,NumPackedFields, MaxNumTokens, MaxNumValues> {
+
+    fn get_length(self) -> u32 {
+        assert(self.layer_context == ARRAY_LAYER, "can only get length of an array type");
+        let parent_entry = JSONEntry::from_field(self.packed_json_entries[self.layer_index_in_transcript]);
+        parent_entry.num_children as u32
+    }
+
+    fn get_array<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> Option<Self> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+        let (exists, key_index) = self.key_exists_impl(key, KeyBytes);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+
+        assert(entry.entry_type == BEGIN_ARRAY_TOKEN, "key does not describe an object");
+
+        let mut result: Option<JSON<NumBytes, NumPackedFields, MaxNumTokens, MaxNumValues>> = Option::none();
+        if (exists) {
+            let mut r = self;
+            r.layer_id = entry.parent_index;
+            r.layer_context = ARRAY_LAYER;
+            r.layer_index_in_transcript = key_index;
+            result = Option::some(r);
+        }
+        result
+    }
+
+    fn get_array_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> Option<Self> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+        let (exists, key_index) = self.key_exists_impl(key, key_length);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+
+        // TODO: ADD A layer_context VARIABLE INTO JSON WHICH DESCRIBES WHETHER WE ARE AN OBJECT, ARRAY OR SINGLE VALUE
+        assert(entry.entry_type == BEGIN_ARRAY_TOKEN, "key does not describe an object");
+
+        let mut result: Option<JSON<NumBytes, NumPackedFields, MaxNumTokens, MaxNumValues>> = Option::none();
+        if (exists) {
+            let mut r = self;
+            r.layer_id = entry.parent_index;
+            r.layer_context = ARRAY_LAYER;
+            r.layer_index_in_transcript = key_index;
+            result = Option::some(r);
+        }
+        result
+    }
+
+    fn map<U, let MaxElements: u32, let MaxElementBytes: u32>(
+        self,
+        f: fn(JSONValue<MaxElementBytes>) -> U
+    ) -> [U; MaxElements] where U: std::default::Default {
+        assert(self.layer_context == ARRAY_LAYER, "can only call map on an array");
+
+        let entry = JSONEntry::from_field(self.packed_json_entries[self.layer_index_in_transcript]);
+
+        let num_children = entry.num_children;
+        let mut r: [U; MaxElements] = [U::default(); MaxElements];
+
+        for i in 0..MaxElements {
+            let valid = lt_field_16_bit(i as Field, num_children);
+            let entry_index = (entry.child_pointer + i as Field) * valid as Field;
+            let child_entry = JSONEntry::from_field(self.packed_json_entries[entry_index]);
+
+            let mut parsed_string: [u8; MaxElementBytes] = [0; MaxElementBytes];
+            for j in 0..MaxElementBytes {
+                let byte_valid = lt_field_16_bit(j as Field, child_entry.json_length);
+                // n.b. conditionally setting index to 0 can be removed if we ensure json is padded such that this index does not overflow json bytes
+                let byte = self.json[(child_entry.json_pointer + i as Field) * valid as Field];
+                // TODO improve efficiency? measure...
+                if (byte_valid) {
+                    parsed_string[i] = byte;
+                }
+            }
+
+            if (valid) {
+                r[i] = f(
+                    JSONValue { length: child_entry.json_length, value: parsed_string, value_type: child_entry.entry_type }
+                );
+            }
+        }
+        r
+    }
+}

src/get_array.nr

@@ -0,0 +1,111 @@
+use crate::getters;
+use dep::noir_sort;
+use crate::json_entry::JSONEntry;
+use crate::redux::JSON;
+use crate::keymap;
+use crate::lt::{lt_field_8_bit, lt_field_16_bit, assert_lt_240_bit, assert_gt_240_bit};
+use crate::redux_tables::{
+    OBJECT_LAYER, ARRAY_LAYER, NUMERIC_TOKEN, LITERAL_TOKEN, STRING_TOKEN, BEGIN_OBJECT_TOKEN,
+    BEGIN_ARRAY_TOKEN, ASCII_TO_NUMBER, ESCAPE_SEQUENCE_END_CHARS, ESCAPE_SEQUENCE_START_CHARS,
+    ESCAPE_SEQUENCE_REPLACEMENT
+};
+use crate::keyhash::Hasher;
+use crate::keyhash::get_keyhash;
+use crate::slice_field::slice_fields;
+
+global MAX_LITERAL_LENGTH_AS_STRING = 5;
+global LITERAL_OFFSET_SHIFT: [Field; 6] = [
+   0x10000000000, 0x100000000, 0x1000000, 0x10000, 0x100,1
+];
+fn extract_literal_from_array(arr: [u8; MAX_LITERAL_LENGTH_AS_STRING], json_length: Field) -> JSONLiteral {
+    let false_field = 0x66616c7365;
+    let true_field = 0x74727565;
+    let null_field = 0x6e756c6c;
+
+    let mut parsed_literal: Field = 0;
+    for i in 0..MAX_LITERAL_LENGTH_AS_STRING {
+        parsed_literal *= 0x100;
+
+        let value = arr[i] as Field;
+        parsed_literal += value;
+    }
+    parsed_literal /= LITERAL_OFFSET_SHIFT[json_length];
+    let is_false = parsed_literal == false_field;
+    let is_null = parsed_literal == null_field;
+    let is_true = parsed_literal == true_field;
+    JSONLiteral::new(is_true, is_false, is_null)
+}
+
+struct JSONLiteral {
+    value: Field,
+}
+
+impl JSONLiteral {
+    fn new(is_true: bool, is_false: bool, is_null: bool) -> Self {
+        assert(is_false as Field + is_null as Field + is_true as Field == 1, "parse literal: invalid entry");
+        JSONLiteral { value: is_true as Field * 2 + is_null as Field }
+    }
+    fn is_true(self) -> bool {
+        self.value == 2
+    }
+    fn is_null(self) -> bool {
+        self.value == 1
+    }
+    fn is_false(self) -> bool {
+        self.value == 0
+    }
+    fn to_bool(self) -> bool {
+        self.value == 2
+    }
+}
+
+impl<let NumBytes: u32, let NumPackedFields: u16, let MaxNumTokens: u16, let MaxNumValues: u16> JSON<NumBytes,NumPackedFields, MaxNumTokens, MaxNumValues> {
+
+    fn get_literal<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> Option<JSONLiteral> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let (exists, entry) = self.get_json_entry(key);
+        assert(
+            (entry.entry_type - LITERAL_TOKEN) * exists as Field == 0, "get_literal: entry exists but is not a literal!"
+        );
+        let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] = self.extract_string_entry(entry);
+
+        Option { _is_some: exists, _value: extract_literal_from_array(parsed_string, entry.json_length) }
+    }
+
+    fn get_literal_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> Option<JSONLiteral> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let (exists, entry) = self.get_json_entry_var(key, key_length);
+        assert(
+            (entry.entry_type - LITERAL_TOKEN) * exists as Field == 0, "get_literal_var: entry exists but is not a literal!"
+        );
+        let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] = self.extract_string_entry(entry);
+
+        Option { _is_some: exists, _value: extract_literal_from_array(parsed_string, entry.json_length) }
+    }
+
+    fn get_literal_unchecked_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> JSONLiteral {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let entry= self.get_json_entry_unchecked_var(key, key_length);
+        assert(
+            entry.entry_type == LITERAL_TOKEN, "get_literal_unchecked_var: entry exists but is not a literal!"
+        );
+        let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] = self.extract_string_entry(entry);
+
+        extract_literal_from_array(parsed_string, entry.json_length)
+    }
+
+    fn get_literal_unchecked<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> JSONLiteral {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let entry= self.get_json_entry_unchecked(key);
+        assert(
+            entry.entry_type == LITERAL_TOKEN, "get_literal_unchecked_var: entry exists but is not a literal!"
+        );
+        let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] = self.extract_string_entry(entry);
+
+        extract_literal_from_array(parsed_string, entry.json_length)
+    }
+}

src/get_literal.nr

@@ -0,0 +1,107 @@
+use crate::getters;
+use dep::noir_sort;
+use crate::json_entry::JSONEntry;
+use crate::redux::JSON;
+use crate::keymap;
+use crate::lt::{lt_field_8_bit, lt_field_16_bit, assert_lt_240_bit, assert_gt_240_bit};
+use crate::redux_tables::{
+    OBJECT_LAYER, ARRAY_LAYER, NUMERIC_TOKEN, LITERAL_TOKEN, STRING_TOKEN, BEGIN_OBJECT_TOKEN,
+    BEGIN_ARRAY_TOKEN, ASCII_TO_NUMBER, ESCAPE_SEQUENCE_END_CHARS, ESCAPE_SEQUENCE_START_CHARS,
+    ESCAPE_SEQUENCE_REPLACEMENT
+};
+use crate::keyhash::Hasher;
+use crate::keyhash::get_keyhash;
+use crate::slice_field::slice_fields;
+
+global U64_LENGTH_AS_BASE10_STRING = 20;
+global NUMBER_OFFSET_SHIFT: [Field; 21] = [
+    100000000000000000000,10000000000000000000,1000000000000000000,100000000000000000,10000000000000000,1000000000000000,100000000000000,10000000000000, 1000000000000, 100000000000, 10000000000, 1000000000, 100000000,10000000,1000000,100000,10000,1000,100,10,1
+];
+fn extract_number_from_array(arr: [u8; U64_LENGTH_AS_BASE10_STRING], json_length: Field) -> u64 {
+    let mut parsed_number: Field = 0;
+    for i in 0..U64_LENGTH_AS_BASE10_STRING {
+        parsed_number *= 10;
+
+        let value = ASCII_TO_NUMBER[arr[i]] as Field;
+        parsed_number += value;
+    }
+    parsed_number /= NUMBER_OFFSET_SHIFT[json_length];
+    parsed_number as u64
+}
+impl<let NumBytes: u32, let NumPackedFields: u16, let MaxNumTokens: u16, let MaxNumValues: u16> JSON<NumBytes,NumPackedFields, MaxNumTokens, MaxNumValues> {
+
+    fn get_number<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> Option<u64> {
+        let (exists, entry) = self.get_json_entry(key);
+        assert(
+            (entry.entry_type - NUMERIC_TOKEN) * exists as Field == 0, "get_number: entry exists but is not a number!"
+        );
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+
+        Option { _is_some: exists, _value: extract_number_from_array(parsed_string, entry.json_length) }
+    }
+
+    fn get_number_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> Option<u64> {
+        let (exists, entry) = self.get_json_entry_var(key, key_length);
+        assert(
+            (entry.entry_type - NUMERIC_TOKEN) * exists as Field == 0, "get_number: entry exists but is not a number!"
+        );
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+
+        Option { _is_some: exists, _value: extract_number_from_array(parsed_string, entry.json_length) }
+    }
+
+    fn get_number_unchecked<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> u64 {
+        let  entry = self.get_json_entry_unchecked(key);
+        assert(entry.entry_type == NUMERIC_TOKEN, "get_number_unchecked: entry exists but is not a number!");
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+
+        extract_number_from_array(parsed_string, entry.json_length)
+    }
+
+    fn get_number_unchecked_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> u64 {
+        let  entry = self.get_json_entry_unchecked_var(key, key_length);
+        assert(entry.entry_type == NUMERIC_TOKEN, "get_number_unchecked: entry exists but is not a number!");
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+
+        extract_number_from_array(parsed_string, entry.json_length)
+    }
+
+    fn get_array_element_as_number(self, array_index: Field) -> Option<u64> {
+        assert(self.layer_context == ARRAY_LAYER, "can only acceess array elements from array");
+
+        let parent_entry = JSONEntry::from_field(self.packed_json_entries[self.layer_index_in_transcript]);
+
+        let valid = lt_field_16_bit(array_index, parent_entry.num_children);
+        let entry_index = (parent_entry.child_pointer + array_index) * valid as Field;
+
+        let entry = JSONEntry::from_field(self.packed_json_entries[entry_index]);
+
+        assert(
+            (entry.entry_type - NUMERIC_TOKEN) * valid as Field == 0, "get_number: entry exists but is not a number!"
+        );
+
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+        let result = extract_number_from_array(parsed_string, entry.json_length);
+
+        Option { _is_some: valid, _value: result }
+    }
+
+    fn get_number_from_array_unchecked(self, array_index: Field) -> u64 {
+        assert(self.layer_context == ARRAY_LAYER, "can only acceess array elements from array");
+
+        let parent_entry = JSONEntry::from_field(self.packed_json_entries[self.layer_index_in_transcript]);
+
+        let valid = lt_field_16_bit(array_index, parent_entry.num_children);
+        assert(valid, "array overflow");
+        let entry_index = (parent_entry.child_pointer + array_index);
+
+        let entry = JSONEntry::from_field(self.packed_json_entries[entry_index]);
+
+        assert(
+            (entry.entry_type - NUMERIC_TOKEN) * valid as Field == 0, "get_number: entry exists but is not a number!"
+        );
+
+        let mut parsed_string: [u8; U64_LENGTH_AS_BASE10_STRING] = self.extract_string_entry(entry);
+        extract_number_from_array(parsed_string, entry.json_length)
+    }
+}

src/get_number.nr

@@ -0,0 +1,75 @@
+use crate::getters;
+use dep::noir_sort;
+use crate::json_entry::JSONEntry;
+use crate::redux::JSON;
+use crate::keymap;
+use crate::lt::{lt_field_8_bit, lt_field_16_bit, assert_lt_240_bit, assert_gt_240_bit};
+use crate::redux_tables::{
+    OBJECT_LAYER, ARRAY_LAYER, NUMERIC_TOKEN, LITERAL_TOKEN, STRING_TOKEN, BEGIN_OBJECT_TOKEN,
+    BEGIN_ARRAY_TOKEN, ASCII_TO_NUMBER, ESCAPE_SEQUENCE_END_CHARS, ESCAPE_SEQUENCE_START_CHARS,
+    ESCAPE_SEQUENCE_REPLACEMENT
+};
+use crate::keyhash::Hasher;
+use crate::keyhash::get_keyhash;
+use crate::slice_field::slice_fields;
+
+impl<let NumBytes: u32, let NumPackedFields: u16, let MaxNumTokens: u16, let MaxNumValues: u16> JSON<NumBytes,NumPackedFields, MaxNumTokens, MaxNumValues> {
+
+    fn get_object_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> Option<Self> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let (exists, key_index) = self.key_exists_impl(key, key_length);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+        assert(
+            (entry.entry_type - BEGIN_OBJECT_TOKEN) * exists as Field == 0, "get_object: entry exists but is not an object!"
+        );
+
+        let mut r = self;
+        r.layer_id = entry.parent_index;
+        r.layer_context = OBJECT_LAYER;
+        r.layer_index_in_transcript = key_index;
+        Option { _is_some: exists, _value: r }
+    }
+
+    fn get_object<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> Option<Self> {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+
+        let (exists, key_index) = self.key_exists_impl(key, KeyBytes);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+        assert(
+            (entry.entry_type - BEGIN_OBJECT_TOKEN) * exists as Field == 0, "get_object: entry exists but is not an object!"
+        );
+
+        let mut r = self;
+        r.layer_id = entry.parent_index;
+        r.layer_context = OBJECT_LAYER;
+        r.layer_index_in_transcript = key_index;
+        Option { _is_some: exists, _value: r }
+    }
+
+    fn get_object_unchecked_var<let KeyBytes: u16>(self, key: [u8; KeyBytes], key_length: u16) -> Self {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index_var(key, key_length);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+        assert(entry.entry_type == BEGIN_OBJECT_TOKEN, "get_object: entry exists but is not an object!");
+
+        let mut r = self;
+        r.layer_id = entry.parent_index;
+        r.layer_context = OBJECT_LAYER;
+        r.layer_index_in_transcript = key_index;
+        r
+    }
+
+    fn get_object_unchecked<let KeyBytes: u16>(self, key: [u8; KeyBytes]) -> Self {
+        assert(self.layer_context != ARRAY_LAYER, "cannot extract array elements via a key");
+        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index_var(key, KeyBytes);
+        let entry: JSONEntry = JSONEntry::from_field(self.packed_json_entries[key_index]);
+        assert(entry.entry_type == BEGIN_OBJECT_TOKEN, "get_object: entry exists but is not an object!");
+
+        let mut r = self;
+        r.layer_id = entry.parent_index;
+        r.layer_context = OBJECT_LAYER;
+        r.layer_index_in_transcript = key_index;
+        r
+    }
+}