feat: implement MPT part of generic extraction (Part 1)

Cargo.toml

@@ -14,7 +14,7 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
-alloy = { version = "0.2", default-features = false, features = [
+alloy = { version = "0.4", default-features = false, features = [
   "consensus",
   "contract",
   "getrandom",

groth16-framework/tests/common/context.rs

@@ -8,8 +8,8 @@ use verifiable_db::{
     api::WrapCircuitParams,
     revelation::api::Parameters as RevelationParameters,
     test_utils::{
-        MAX_NUM_ITEMS_PER_OUTPUT, MAX_NUM_OUTPUTS, MAX_NUM_PLACEHOLDERS, MAX_NUM_PREDICATE_OPS,
-        MAX_NUM_RESULT_OPS,
+        INDEX_TREE_MAX_DEPTH, MAX_NUM_COLUMNS, MAX_NUM_ITEMS_PER_OUTPUT, MAX_NUM_OUTPUTS,
+        MAX_NUM_PLACEHOLDERS, MAX_NUM_PREDICATE_OPS, MAX_NUM_RESULT_OPS, ROW_TREE_MAX_DEPTH,
     },
 };
 
@@ -18,10 +18,14 @@ pub(crate) struct TestContext {
     pub(crate) preprocessing_circuits: TestingRecursiveCircuits<F, C, D, NUM_PREPROCESSING_IO>,
     pub(crate) query_circuits: TestingRecursiveCircuits<F, C, D, NUM_QUERY_IO>,
     pub(crate) revelation_params: RevelationParameters<
+        ROW_TREE_MAX_DEPTH,
+        INDEX_TREE_MAX_DEPTH,
+        MAX_NUM_COLUMNS,
+        MAX_NUM_PREDICATE_OPS,
+        MAX_NUM_RESULT_OPS,
         MAX_NUM_OUTPUTS,
         MAX_NUM_ITEMS_PER_OUTPUT,
         MAX_NUM_PLACEHOLDERS,
-        { 2 * (MAX_NUM_PREDICATE_OPS + MAX_NUM_RESULT_OPS) },
     >,
     pub(crate) wrap_circuit:
         WrapCircuitParams<MAX_NUM_OUTPUTS, MAX_NUM_ITEMS_PER_OUTPUT, MAX_NUM_PLACEHOLDERS>,
@@ -39,10 +43,14 @@ impl TestContext {
 
         // Create the revelation parameters.
         let revelation_params = RevelationParameters::<
+            ROW_TREE_MAX_DEPTH,
+            INDEX_TREE_MAX_DEPTH,
+            MAX_NUM_COLUMNS,
+            MAX_NUM_PREDICATE_OPS,
+            MAX_NUM_RESULT_OPS,
             MAX_NUM_OUTPUTS,
             MAX_NUM_ITEMS_PER_OUTPUT,
             MAX_NUM_PLACEHOLDERS,
-            { 2 * (MAX_NUM_PREDICATE_OPS + MAX_NUM_RESULT_OPS) },
         >::build(
             query_circuits.get_recursive_circuit_set(),
             preprocessing_circuits.get_recursive_circuit_set(),

groth16-framework/tests/common/query.rs

@@ -30,19 +30,6 @@ impl TestContext {
         let max_block_number = 76;
         let test_data = TestRevelationData::sample(min_block_number, max_block_number);
 
-        let placeholder_hash_ids = QueryInput::<
-            MAX_NUM_COLUMNS,
-            MAX_NUM_PREDICATE_OPS,
-            MAX_NUM_RESULT_OPS,
-            MAX_NUM_ITEMS_PER_OUTPUT,
-        >::ids_for_placeholder_hash(
-            test_data.predicate_operations(),
-            test_data.results(),
-            test_data.placeholders(),
-            test_data.query_bounds(),
-        )
-        .unwrap();
-
         // Generate the query proof.
         let [query_proof] = self
             .query_circuits
@@ -66,12 +53,13 @@ impl TestContext {
             preprocessing_proof,
             test_data.query_bounds(),
             test_data.placeholders(),
-            placeholder_hash_ids,
+            test_data.predicate_operations(),
+            test_data.results(),
         )
         .unwrap();
         let revelation_proof = self
             .revelation_params
-            .generate_proof(input, self.query_circuits.get_recursive_circuit_set())
+            .generate_proof(input, self.query_circuits.get_recursive_circuit_set(), None)
             .unwrap();
         let revelation_proof = ProofWithVK::deserialize(&revelation_proof).unwrap();
         let (revelation_proof_with_pi, _) = revelation_proof.clone().into();

mp2-common/src/array.rs

@@ -166,16 +166,21 @@ impl<const MAX_LEN: usize> VectorWire<Target, MAX_LEN> {
     ) -> Array<Target, PAD_LEN> {
         let zero = b.zero();
         let pad_t = b.constant(F::from_canonical_usize(PAD_LEN));
+        // initialize is_lt to false
+        let mut is_lt = b._false();
         Array {
             arr: create_array(|i| {
                 // ((pad_len - i) < real_len) * vec[real_len - (pad_len-i)]
                 // i.e. reading value backwards and inserting in order
                 let it = b.constant(F::from_canonical_usize(i));
                 let jt = b.sub(pad_t, it);
-                let is_lt =
-                    less_than_or_equal_to(b, jt, self.real_len, (PAD_LEN.ilog2() + 1) as usize);
+                // update is_lt incrementally: it should become true when PAD_LEN-i == self.real_len
+                let is_eq = b.is_equal(jt, self.real_len);
+                is_lt = b.or(is_lt, is_eq);
                 let idx = b.sub(self.real_len, jt);
-                let val = self.arr.value_at_failover(b, idx);
+                let idx = b.select(is_lt, idx, zero); // workaround to always have a in-bound access in
+                                                      // the array
+                let val = self.arr.value_at(b, idx);
                 b.select(is_lt, val, zero)
             }),
         }