merge

Author: jialinli98

.github/workflows/benchmark.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Install Nargo
         uses: noir-lang/[email protected]
         with:
-          toolchain: 1.0.0-beta.6
+          toolchain: 1.0.0-beta.12
 
       - name: Install bb
         run: |

.github/workflows/test.yml

@@ -8,7 +8,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  MINIMUM_NOIR_VERSION: v1.0.0-beta.1
+  MINIMUM_NOIR_VERSION: 1.0.0-beta.12
 
 jobs:
   noir-version-list:

README.md

@@ -104,9 +104,9 @@ For numbers larger than 64 bits, the method `get_value` will work, which will re
 
 ### Fine-grained maximum parameter control
 
-If the predefined JSON types are not sufficient for your use case, you can define a JSON object with a custom parametrisation:
+If the predefined JSON types are not sufficient for your use case, you can define a JSON object with a custom parameterization:
 
-The JSON struct in `dep::json_parser::json::JSON` is parametrised with the following parameters:
+The JSON struct in `dep::json_parser::json::JSON` is parameterized with the following parameters:
 
 `struct JSON<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let MaxNumValues: u32, let MaxKeyFields: u32>`
 
@@ -116,11 +116,11 @@ The JSON struct in `dep::json_parser::json::JSON` is parametrised with the follo
 - `MaxNumValues`: the maximum number of values in the json blob _plus one_
 - `MaxKeyFields`: the largest size a key can take (in bytes) equals `MaxKeyFields * 31`
 
-e.g. to take the existing 1kb JSON paramters, but also support 124-byte keys, use `JSON<1024, 37, 128, 65, 4>`
+e.g. to take the existing 1kb JSON parameters, but also support 124-byte keys, use `JSON<1024, 37, 128, 65, 4>`
 
 ### Making queries with keys of unknown length
 
-If you are deriving a key to look up in-circuit and you do not know the maximum length of the key, all query methods have a version with a `_var` suffix (e.g. `JSON::get_string_var`), which accepts the key as a `BoundedVec`
+If you are deriving a key to look up in-circuit and you do not know the maximum length of the key, all query methods accept the key as a `BoundedVec`
 
 #  Architecture
 ### Overview

src/_string_tools/slice_packed_field.nr

@@ -1,6 +1,7 @@
 use crate::_comparison_tools::lt::lt_field_16_bit;
 use crate::enums::Layer::ARRAY_LAYER;
 use crate::enums::Token::END_ARRAY_TOKEN;
+use crate::getters::KeyHashable;
 use crate::json::JSON;
 use crate::json::JSONValue;
 use crate::json_entry::JSONEntry;
@@ -26,20 +27,11 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
     /// if the root JSON is an object, extract an array given by `key`
     ///
     /// returns an Option<JSON> where, if the array exists, the JSON object will have the requested array as its root value
-    pub fn get_array<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Option<Self> {
-        self.get_array_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// if the root JSON is an object, extract an array given by `key`
-    ///
-    /// will revert if the array does not exist
-    pub fn get_array_unchecked<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Self {
-        self.get_array_unchecked_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// same as `get_array` for where the key length may be less than KeyBytes
-    pub fn get_array_var<let KeyBytes: u32>(self, key: BoundedVec<u8, KeyBytes>) -> Option<Self> {
-        let (exists, entry, key_index) = self.get_json_entry_var(key);
+    pub(crate) fn get_array<K>(self, key: K) -> Option<Self>
+    where
+        K: KeyHashable,
+    {
+        let (exists, entry, key_index) = self.get_json_entry(key);
         if !exists {
             assert_eq(
                 entry.entry_type,
@@ -57,11 +49,16 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         }
     }
 
-    /// same as `get_array_unchecked` for where the key length may be less than KeyBytes
-    pub fn get_array_unchecked_var<let KeyBytes: u32>(self, key: BoundedVec<u8, KeyBytes>) -> Self {
+    /// if the root JSON is an object, extract an array given by `key`
+    ///
+    /// will revert if the array does not exist
+    pub(crate) fn get_array_unchecked<K>(self, key: K) -> Self
+    where
+        K: KeyHashable,
+    {
         assert(self.layer_type_of_root != ARRAY_LAYER, "cannot extract array elements via a key");
 
-        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index_var(key);
+        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index(key);
         assert(entry.entry_type == END_ARRAY_TOKEN as Field, "key does not describe an object");
 
         self.update_json_array(entry, key_index)

src/get_array.nr

@@ -1,4 +1,5 @@
 use crate::enums::Token::LITERAL_TOKEN;
+use crate::getters::KeyHashable;
 use crate::json::JSON;
 use crate::utils::cast_num_to_u32;
 
@@ -63,26 +64,14 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
     /// if the root JSON is an object, extract a literal value given by `key`
     ///
     /// returns an Option<JSONLiteral> which will be null if the literal does not exist
-    pub fn get_literal<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Option<JSONLiteral> {
-        self.get_literal_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// if the root JSON is an object, extract a literal value given by `key`
-    ///
-    /// will revert if the literal does not exist
-    pub fn get_literal_unchecked<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> JSONLiteral {
-        self.get_literal_unchecked_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// same as `get_literal` for where the key length may be less than KeyBytes
-    pub fn get_literal_var<let KeyBytes: u32>(
-        self,
-        key: BoundedVec<u8, KeyBytes>,
-    ) -> Option<JSONLiteral> {
-        let (exists, entry, _) = self.get_json_entry_var(key);
+    pub(crate) fn get_literal<K>(self, key: K) -> Option<JSONLiteral>
+    where
+        K: KeyHashable,
+    {
+        let (exists, entry, _) = self.get_json_entry(key);
         assert(
             (entry.entry_type - LITERAL_TOKEN as Field) * exists as Field == 0,
-            "get_literal_var: entry exists but is not a literal!",
+            "get_literal: entry exists but is not a literal!",
         );
         let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] =
             self.extract_string_entry(entry);
@@ -94,15 +83,17 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         }
     }
 
-    /// same as `get_literal_unchecked` for where the key length may be less than KeyBytes
-    pub fn get_literal_unchecked_var<let KeyBytes: u32>(
-        self,
-        key: BoundedVec<u8, KeyBytes>,
-    ) -> JSONLiteral {
-        let entry = self.get_json_entry_unchecked_var(key);
+    /// if the root JSON is an object, extract a literal value given by `key`
+    ///
+    /// will revert if the literal does not exist
+    pub(crate) fn get_literal_unchecked<K>(self, key: K) -> JSONLiteral
+    where
+        K: KeyHashable,
+    {
+        let entry = self.get_json_entry_unchecked(key);
         assert(
             entry.entry_type == LITERAL_TOKEN as Field,
-            "get_literal_unchecked_var: entry exists but is not a literal!",
+            "get_literal_unchecked: entry exists but is not a literal!",
         );
         let mut parsed_string: [u8; MAX_LITERAL_LENGTH_AS_STRING] =
             self.extract_string_entry(entry);

src/get_literal.nr

@@ -1,4 +1,5 @@
 use crate::enums::Token::NUMERIC_TOKEN;
+use crate::getters::KeyHashable;
 use crate::json::JSON;
 use crate::json_tables::ASCII_TO_NUMBER;
 use crate::utils::cast_num_to_u32;
@@ -49,20 +50,11 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
     /// if the root JSON is an object, extract a numeric value given by `key`
     ///
     /// returns an Option<u64> which will be null if the key does not exist
-    pub fn get_number<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Option<u64> {
-        self.get_number_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// if the root JSON is an object, extract a u64 value given by `key`
-    ///
-    /// will revert if the number does not exist
-    pub fn get_number_unchecked<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> u64 {
-        self.get_number_unchecked_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// same as `get_number` for where the key length may be less than KeyBytes
-    pub fn get_number_var<let KeyBytes: u32>(self, key: BoundedVec<u8, KeyBytes>) -> Option<u64> {
-        let (exists, entry, _) = self.get_json_entry_var(key);
+    pub(crate) fn get_number<K>(self, key: K) -> Option<u64>
+    where
+        K: KeyHashable,
+    {
+        let (exists, entry, _) = self.get_json_entry(key);
         assert(
             (entry.entry_type - NUMERIC_TOKEN as Field) * exists as Field == 0,
             "get_number: entry exists but is not a number!",
@@ -76,9 +68,14 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         }
     }
 
-    /// same as `get_number_unchecked` for where the key length may be less than KeyBytes
-    pub fn get_number_unchecked_var<let KeyBytes: u32>(self, key: BoundedVec<u8, KeyBytes>) -> u64 {
-        let entry = self.get_json_entry_unchecked_var(key);
+    /// if the root JSON is an object, extract a u64 value given by `key`
+    ///
+    /// will revert if the number does not exist
+    pub(crate) fn get_number_unchecked<K>(self, key: K) -> u64
+    where
+        K: KeyHashable,
+    {
+        let entry = self.get_json_entry_unchecked(key);
         assert(
             entry.entry_type == NUMERIC_TOKEN as Field,
             "get_number_unchecked: entry exists but is not a number!",

src/get_number.nr

@@ -1,5 +1,6 @@
 use crate::enums::Layer::{ARRAY_LAYER, OBJECT_LAYER};
 use crate::enums::Token::END_OBJECT_TOKEN;
+use crate::getters::KeyHashable;
 use crate::json::JSON;
 use crate::json_entry::JSONEntry;
 
@@ -16,20 +17,11 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
     /// if the root JSON is an object, extract a child object given by `key`
     ///
     /// returns an Option<JSON> where, if the object exists, the JSON object will have the requested object as its root value
-    pub fn get_object<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Option<Self> {
-        self.get_object_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// if the root JSON is an object, extract a child object given by `key`
-    ///
-    /// will revert if the requested object does not exist
-    pub fn get_object_unchecked<let KeyBytes: u32>(self, key: [u8; KeyBytes]) -> Self {
-        self.get_object_unchecked_var(BoundedVec::from_parts_unchecked(key, KeyBytes))
-    }
-
-    /// same as `get_object` for where the key length may be less than KeyBytes
-    pub fn get_object_var<let KeyBytes: u32>(self, key: BoundedVec<u8, KeyBytes>) -> Option<Self> {
-        let (exists, entry, key_index) = self.get_json_entry_var(key);
+    pub(crate) fn get_object<K>(self, key: K) -> Option<Self>
+    where
+        K: KeyHashable,
+    {
+        let (exists, entry, key_index) = self.get_json_entry(key);
         if exists {
             assert_eq(
                 entry.entry_type,
@@ -47,13 +39,15 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         }
     }
 
-    /// same as `get_object_unchecked` for where the key length may be less than KeyBytes
-    pub fn get_object_unchecked_var<let KeyBytes: u32>(
-        self,
-        key: BoundedVec<u8, KeyBytes>,
-    ) -> Self {
+    // if the root JSON is an object, extract a child object given by `key`
+    ///
+    /// will revert if the requested object does not exist
+    pub(crate) fn get_object_unchecked<K>(self, key: K) -> Self
+    where
+        K: KeyHashable,
+    {
         assert(self.layer_type_of_root != ARRAY_LAYER, "cannot extract array elements via a key");
-        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index_var(key);
+        let (entry, key_index) = self.get_json_entry_unchecked_with_key_index(key);
         let entry: JSONEntry = self.json_entries_packed[key_index].into();
         assert_eq(
             entry.entry_type,
@@ -117,19 +111,19 @@ fn test_object() {
     let not_real = B.get_object("bartholomew tony Harrison IV".as_bytes());
     assert(not_real.is_some() == false);
 
-    let C = B.get_object_unchecked_var(BoundedVec::from_parts_unchecked(
+    let C = B.get_object_unchecked(BoundedVec::from_parts_unchecked(
         "bartholomew tony Harrison III".as_bytes(),
         29,
     ));
     assert_eq(JSONEntry::from(C.json_entries_packed[C.root_index_in_transcript]).num_children, 1);
 
-    let C = B.get_object_var(BoundedVec::from_parts_unchecked(
+    let C = B.get_object(BoundedVec::from_parts_unchecked(
         "bartholomew tony Harrison III".as_bytes(),
         28,
     ));
     assert(C.is_some() == false);
 
-    let C = B.get_object_var(BoundedVec::from_parts_unchecked(
+    let C = B.get_object(BoundedVec::from_parts_unchecked(
         "bartholomew tony Harrison IIIekurfgaeoiurh".as_bytes(),
         29,
     ));