chore: remove methods from implementation (#81)

Co-authored-by: Tom French <[email protected]>

Author: jialinli98

src/getters.nr

@@ -2,7 +2,7 @@ use crate::_comparison_tools::lt::{assert_gt_240_bit, assert_lt_240_bit, lt_fiel
 use crate::_string_tools::string_chopper::slice_string;
 use crate::enums::Layer::ARRAY_LAYER;
 use crate::json::JSON;
-use crate::json_entry::JSONEntry;
+use crate::json_entry::{JSONEntry, JSONEntryPacked};
 use crate::keyhash::ByteHasher;
 use crate::keymap::KeyIndexData;
 use crate::utils::cast_num_to_u32;
@@ -57,7 +57,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: The assertion below checks that the keyhash is stored in the the index returned by the unconstrained function
-        let key_index = unsafe { self.find_key_in_map(keyhash) };
+        let key_index = unsafe { find_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
 
         assert_eq(self.key_hashes[key_index], keyhash, "get_json_entry_unchecked: key not found");
         let entry: JSONEntry = self.json_entries_packed[key_index].into();
@@ -97,7 +97,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: The assertion below checks that the keyhash is stored in the the index returned by the unconstrained function
-        let key_index = unsafe { self.find_key_in_map(keyhash) };
+        let key_index = unsafe { find_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
 
         assert_eq(self.key_hashes[key_index], keyhash, "get_json_entry_unchecked: key not found");
         let entry: JSONEntry = self.json_entries_packed[key_index].into();
@@ -121,7 +121,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: The assertion below checks that the keyhash is stored in the the index returned by the unconstrained function
-        let key_index = unsafe { self.find_key_in_map(keyhash) };
+        let key_index = unsafe { find_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
 
         assert_eq(self.key_hashes[key_index], keyhash, "get_json_entry_unchecked: key not found");
         let entry: JSONEntry = self.json_entries_packed[key_index].into();
@@ -144,7 +144,7 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: The assertion below checks that the keyhash is stored in the the index returned by the unconstrained function
-        let key_index = unsafe { self.find_key_in_map(keyhash) };
+        let key_index = unsafe { find_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
 
         assert_eq(self.key_hashes[key_index], keyhash, "get_json_entry_unchecked: key not found");
         let entry: JSONEntry = self.json_entries_packed[key_index].into();
@@ -173,82 +173,6 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         result
     }
 
-    pub(crate) unconstrained fn find_key_in_map(self, target: Field) -> u32 {
-        let mut found_index: u32 = 0;
-        let mut found: bool = false;
-        for i in 0..MaxNumValues {
-            let key_hash = self.key_hashes[i];
-            if (key_hash == target) {
-                found_index = i;
-                found = true;
-                break;
-            }
-        }
-        assert(found, "find_key_in_map, key not found");
-        found_index
-    }
-
-    /**
-     * @brief figures out if `target` exists as a key in `self.key_hashes`
-     * @details if `target` does not exist, we return the two indicies of adjacent
-     *          entries in `self.key_hashes`, lhs_index, rhs_index, where
-     *          lhs_index < key_hash < rhs_index
-     **/
-    pub(crate) unconstrained fn search_for_key_in_map(self, target: Field) -> KeySearchResult {
-        let mut found_index: Field = 0;
-        let mut found: bool = false;
-
-        let mut lhs_maximum: Field = 0;
-        let mut rhs_minimum: Field = -1;
-        let mut lhs_maximum_index: Field = 0;
-        let mut rhs_minimum_index: Field = 0;
-        for i in 0..MaxNumValues {
-            let key_hash = self.key_hashes[i];
-            if (key_hash == target) {
-                found_index = i as Field;
-                found = true;
-                break;
-            } else {
-                if key_hash.lt(target) & (lhs_maximum.lt(key_hash)) {
-                    lhs_maximum = key_hash;
-                    lhs_maximum_index = i as Field;
-                }
-                if (target.lt(key_hash)) & (key_hash.lt(rhs_minimum)) {
-                    rhs_minimum = key_hash;
-                    rhs_minimum_index = i as Field;
-                }
-            }
-        }
-        let target_lt_smallest_entry = target.lt(self.key_hashes[0]);
-        let target_gt_largest_entry = self.key_hashes[MaxNumValues - 1].lt(target);
-
-        let result_not_first_or_last =
-            !target_lt_smallest_entry & !target_gt_largest_entry & !found;
-
-        let mut lhs_index = result_not_first_or_last as Field * lhs_maximum_index;
-        let mut rhs_index = result_not_first_or_last as Field * rhs_minimum_index;
-
-        // if target_lt_smallest_entry, rhs_index = 0
-        // if target_gt_largest_entry, lhs_index = TranscriptEntries - 1
-        rhs_index = rhs_index * (1 - target_lt_smallest_entry as Field);
-
-        // we rely here on the fact that target_gt_largest_entry and result_not_first_or_last are mutually exclusive
-        lhs_index = lhs_index + target_gt_largest_entry as Field * (MaxNumValues as Field - 1);
-
-        // If target is FOUND, we want the following:
-        // keyhash[target_index] - 1 < hash < keyhash[target_index] + 1
-        lhs_index = lhs_index + found as Field * found_index;
-        rhs_index = rhs_index + found as Field * found_index;
-
-        KeySearchResult {
-            found,
-            target_lt_smallest_entry,
-            target_gt_largest_entry,
-            lhs_index: lhs_index as u32,
-            rhs_index: rhs_index as u32,
-        }
-    }
-
     /**
      * @brief returns a bool that describes whether a given key exists at the root of the JSON
      **/
@@ -280,7 +204,8 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: The assertion below checks that the keyhash is stored in the the index returned by the unconstrained function
-        let search_result = unsafe { self.search_for_key_in_map(keyhash) };
+        let search_result =
+            unsafe { search_for_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
         if search_result.found {
             assert_eq(search_result.lhs_index, search_result.rhs_index);
         }
@@ -342,7 +267,8 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         let keyhash = keyhash + self.root_id * two_pow_216;
 
         // Safety: the assertion (search_result.lhs_index - search_result.rhs_index) * found == 0 constraints this function
-        let search_result = unsafe { self.search_for_key_in_map(keyhash) };
+        let search_result =
+            unsafe { search_for_key_in_map::<MaxNumValues>(self.key_hashes, keyhash) };
         if search_result.found {
             assert_eq(search_result.lhs_index, search_result.rhs_index);
         }
@@ -376,33 +302,20 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
         (search_result.found, search_result.lhs_index)
     }
 
-    pub(crate) unconstrained fn __get_keys_at_root<let MaxNumKeys: u32>(
-        self,
-    ) -> BoundedVec<Field, MaxNumKeys> {
-        let root_object: JSONEntry =
-            JSONEntry::from(self.json_entries_packed[self.root_index_in_transcript]);
-
-        let mut result_ptr = 0;
-        let mut result: [Field; MaxNumKeys] = [0; MaxNumKeys];
-        for i in 0..MaxNumValues {
-            let target_entry: JSONEntry = JSONEntry::from(self.unsorted_json_entries_packed[i]);
-            if (target_entry.parent_index == self.root_id) {
-                result[result_ptr] = i as Field;
-                result_ptr += 1;
-            }
-        }
-        assert_eq(result_ptr as Field, root_object.num_children);
-
-        BoundedVec::from_parts_unchecked(result, result_ptr as u32)
-    }
-
     pub(crate) fn get_keys_at_root<let MaxNumKeys: u32, let MaxKeyBytes: u32>(
         self,
     ) -> BoundedVec<BoundedVec<u8, MaxKeyBytes>, MaxNumKeys> {
         let root_object: JSONEntry =
             JSONEntry::from(self.json_entries_packed[self.root_index_in_transcript]);
         // Safety: the length of the index is constrained later.
-        let key_indices: BoundedVec<Field, MaxNumKeys> = unsafe { self.__get_keys_at_root() };
+        let key_indices: BoundedVec<Field, MaxNumKeys> = unsafe {
+            __get_keys_at_root::<MaxNumKeys, MaxNumValues>(
+                self.root_id,
+                self.root_index_in_transcript,
+                self.json_entries_packed,
+                self.unsorted_json_entries_packed,
+            )
+        };
 
         assert(key_indices.len() as Field == root_object.num_children);
 
@@ -424,6 +337,109 @@ impl<let NumBytes: u32, let NumPackedFields: u32, let MaxNumTokens: u32, let Max
     }
 }
 
+unconstrained fn find_key_in_map<let MaxNumValues: u32>(
+    key_hashes: [Field; MaxNumValues],
+    target: Field,
+) -> u32 {
+    let mut found_index: u32 = 0;
+    let mut found: bool = false;
+    for i in 0..MaxNumValues {
+        let key_hash = key_hashes[i];
+        if (key_hash == target) {
+            found_index = i;
+            found = true;
+            break;
+        }
+    }
+    assert(found, "find_key_in_map, key not found");
+    found_index
+}
+
+/**
+    * @brief figures out if `target` exists as a key in `self.key_hashes`
+    * @details if `target` does not exist, we return the two indicies of adjacent
+    *          entries in `self.key_hashes`, lhs_index, rhs_index, where
+    *          lhs_index < key_hash < rhs_index
+    **/
+unconstrained fn search_for_key_in_map<let MaxNumValues: u32>(
+    key_hashes: [Field; MaxNumValues],
+    target: Field,
+) -> KeySearchResult {
+    let mut found_index: Field = 0;
+    let mut found: bool = false;
+
+    let mut lhs_maximum: Field = 0;
+    let mut rhs_minimum: Field = -1;
+    let mut lhs_maximum_index: Field = 0;
+    let mut rhs_minimum_index: Field = 0;
+    for i in 0..MaxNumValues {
+        let key_hash = key_hashes[i];
+        if (key_hash == target) {
+            found_index = i as Field;
+            found = true;
+            break;
+        } else {
+            if key_hash.lt(target) & (lhs_maximum.lt(key_hash)) {
+                lhs_maximum = key_hash;
+                lhs_maximum_index = i as Field;
+            }
+            if (target.lt(key_hash)) & (key_hash.lt(rhs_minimum)) {
+                rhs_minimum = key_hash;
+                rhs_minimum_index = i as Field;
+            }
+        }
+    }
+    let target_lt_smallest_entry = target.lt(key_hashes[0]);
+    let target_gt_largest_entry = key_hashes[MaxNumValues - 1].lt(target);
+
+    let result_not_first_or_last = !target_lt_smallest_entry & !target_gt_largest_entry & !found;
+
+    let mut lhs_index = result_not_first_or_last as Field * lhs_maximum_index;
+    let mut rhs_index = result_not_first_or_last as Field * rhs_minimum_index;
+
+    // if target_lt_smallest_entry, rhs_index = 0
+    // if target_gt_largest_entry, lhs_index = TranscriptEntries - 1
+    rhs_index = rhs_index * (1 - target_lt_smallest_entry as Field);
+
+    // we rely here on the fact that target_gt_largest_entry and result_not_first_or_last are mutually exclusive
+    lhs_index = lhs_index + target_gt_largest_entry as Field * (MaxNumValues as Field - 1);
+
+    // If target is FOUND, we want the following:
+    // keyhash[target_index] - 1 < hash < keyhash[target_index] + 1
+    lhs_index = lhs_index + found as Field * found_index;
+    rhs_index = rhs_index + found as Field * found_index;
+
+    KeySearchResult {
+        found,
+        target_lt_smallest_entry,
+        target_gt_largest_entry,
+        lhs_index: lhs_index as u32,
+        rhs_index: rhs_index as u32,
+    }
+}
+
+unconstrained fn __get_keys_at_root<let MaxNumKeys: u32, let MaxNumValues: u32>(
+    root_id: Field,
+    root_index_in_transcript: u32,
+    json_entries_packed: [JSONEntryPacked; MaxNumValues],
+    unsorted_json_entries_packed: [JSONEntryPacked; MaxNumValues],
+) -> BoundedVec<Field, MaxNumKeys> {
+    let root_object: JSONEntry = JSONEntry::from(json_entries_packed[root_index_in_transcript]);
+
+    let mut result_ptr = 0;
+    let mut result: [Field; MaxNumKeys] = [0; MaxNumKeys];
+    for i in 0..MaxNumValues {
+        let target_entry: JSONEntry = JSONEntry::from(unsorted_json_entries_packed[i]);
+        if (target_entry.parent_index == root_id) {
+            result[result_ptr] = i as Field;
+            result_ptr += 1;
+        }
+    }
+    assert_eq(result_ptr as Field, root_object.num_children);
+
+    BoundedVec::from_parts_unchecked(result, result_ptr as u32)
+}
+
 #[test]
 fn test_get_keys_at_root() {
     let s = "{ \"A\": 1, \"foo\": false, \"bar\": { \"one\" : \"A\", \"two\" : \"B\"}, \"baz\": \"12345\"  }";