feat: add dummy circuit to final extraction for indexing Data with no provable extraction

groth16-framework/Cargo.toml

@@ -23,6 +23,7 @@ itertools.workspace = true
 rand.workspace = true
 serial_test.workspace = true
 sha2.workspace = true
+mp2_test = { path = "../mp2-test" }
 
 recursion_framework = { path = "../recursion-framework" }
 verifiable-db = { path = "../verifiable-db" }

groth16-framework/tests/common/context.rs

@@ -3,9 +3,11 @@
 use super::{NUM_PREPROCESSING_IO, NUM_QUERY_IO};
 use groth16_framework::{compile_and_generate_assets, utils::clone_circuit_data};
 use mp2_common::{C, D, F};
+use mp2_test::circuit::TestDummyCircuit;
 use recursion_framework::framework_testing::TestingRecursiveCircuits;
 use verifiable_db::{
     api::WrapCircuitParams,
+    query::pi_len,
     revelation::api::Parameters as RevelationParameters,
     test_utils::{
         INDEX_TREE_MAX_DEPTH, MAX_NUM_COLUMNS, MAX_NUM_ITEMS_PER_OUTPUT, MAX_NUM_OUTPUTS,
@@ -40,6 +42,8 @@ impl TestContext {
 
         // Generate a fake query circuit set.
         let query_circuits = TestingRecursiveCircuits::<F, C, D, NUM_QUERY_IO>::default();
+        let dummy_universal_circuit =
+            TestDummyCircuit::<{ pi_len::<MAX_NUM_ITEMS_PER_OUTPUT>() }>::build();
 
         // Create the revelation parameters.
         let revelation_params = RevelationParameters::<
@@ -52,7 +56,8 @@ impl TestContext {
             MAX_NUM_ITEMS_PER_OUTPUT,
             MAX_NUM_PLACEHOLDERS,
         >::build(
-            query_circuits.get_recursive_circuit_set(),
+            query_circuits.get_recursive_circuit_set(), // unused, so we provide a dummy one
+            dummy_universal_circuit.circuit_data().verifier_data(),
             preprocessing_circuits.get_recursive_circuit_set(),
             preprocessing_circuits
                 .verifier_data_for_input_proofs::<1>()

mp2-common/src/eth.rs

@@ -432,7 +432,7 @@ mod test {
         // holder: 0x188b264aa1456b869c3a92eeed32117ebb835f47
         // NFT id https://opensea.io/assets/ethereum/0xbd3531da5cf5857e7cfaa92426877b022e612cf8/1116
         let mapping_value =
-            Address::from_str("0x188B264AA1456B869C3a92eeeD32117EbB835f47").unwrap();
+            Address::from_str("0x29469395eAf6f95920E59F858042f0e28D98a20B").unwrap();
         let nft_id: u32 = 1116;
         let mapping_key = left_pad32(&nft_id.to_be_bytes());
         let url = get_mainnet_url();

mp2-common/src/group_hashing/mod.rs

@@ -120,6 +120,8 @@ impl ToTargets for QuinticExtensionTarget {
 }
 
 impl FromTargets for CurveTarget {
+    const NUM_TARGETS: usize = CURVE_TARGET_LEN;
+
     fn from_targets(t: &[Target]) -> Self {
         assert!(t.len() >= CURVE_TARGET_LEN);
         let x = QuinticExtensionTarget(t[0..EXTENSION_DEGREE].try_into().unwrap());

mp2-common/src/keccak.rs

@@ -59,6 +59,8 @@ pub type OutputHash = Array<U32Target, PACKED_HASH_LEN>;
 pub type OutputByteHash = Array<Target, HASH_LEN>;
 
 impl FromTargets for OutputHash {
+    const NUM_TARGETS: usize = PACKED_HASH_LEN;
+
     fn from_targets(t: &[Target]) -> Self {
         OutputHash::from_array(array::from_fn(|i| U32Target(t[i])))
     }

mp2-common/src/u256.rs

@@ -500,11 +500,9 @@ impl<F: SerializableRichField<D>, const D: usize> CircuitBuilderU256<F, D>
         left: &UInt256Target,
         right: &UInt256Target,
     ) -> BoolTarget {
-        // left <= right iff left - right requires a borrow or left - right == 0
-        let (res, borrow) = self.sub_u256(left, right);
-        let less_than = BoolTarget::new_unsafe(borrow.0);
-        let is_eq = self.is_zero(&res);
-        self.or(less_than, is_eq)
+        // left <= right iff ! right < left
+        let is_greater = self.is_less_than_u256(right, left);
+        self.not(is_greater)
     }
 
     fn is_zero(&mut self, target: &UInt256Target) -> BoolTarget {
@@ -827,6 +825,7 @@ impl ToTargets for UInt256Target {
 }
 
 impl FromTargets for UInt256Target {
+    const NUM_TARGETS: usize = NUM_LIMBS;
     // Expects big endian limbs as the standard format for IO
     fn from_targets(t: &[Target]) -> Self {
         Self::new_from_be_target_limbs(&t[..NUM_LIMBS]).unwrap()

mp2-common/src/utils.rs

@@ -5,7 +5,7 @@ use anyhow::{anyhow, Result};
 use itertools::Itertools;
 use plonky2::field::extension::Extendable;
 use plonky2::field::goldilocks_field::GoldilocksField;
-use plonky2::hash::hash_types::{HashOut, HashOutTarget, RichField};
+use plonky2::hash::hash_types::{HashOut, HashOutTarget, RichField, NUM_HASH_OUT_ELTS};
 use plonky2::iop::target::{BoolTarget, Target};
 use plonky2::iop::witness::{PartialWitness, WitnessWrite};
 use plonky2::plonk::circuit_builder::CircuitBuilder;
@@ -19,26 +19,25 @@ use sha3::Keccak256;
 
 use crate::array::Targetable;
 use crate::poseidon::{HashableField, H};
+use crate::serialization::circuit_data_serialization::SerializableRichField;
 use crate::{group_hashing::EXTENSION_DEGREE, types::HashOutput, ProofTuple};
-use crate::{D, F};
 
 const TWO_POWER_8: usize = 256;
 const TWO_POWER_16: usize = 65536;
 const TWO_POWER_24: usize = 16777216;
 
-#[allow(dead_code)]
-trait ConnectSlice {
-    fn connect_slice(&mut self, a: &[Target], b: &[Target]);
+// check that the closure $f actually panics, printing $msg as error message if the function
+// did not panic; this macro is employed in tests in place of #[should_panic] to ensure that a
+// panic occurred in the expected function rather than in other parts of the test
+#[macro_export]
+macro_rules! check_panic {
+    ($f: expr, $msg: expr) => {{
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe($f));
+        assert!(result.is_err(), $msg);
+    }};
 }
 
-impl ConnectSlice for CircuitBuilder<F, D> {
-    fn connect_slice(&mut self, a: &[Target], b: &[Target]) {
-        assert_eq!(a.len(), b.len());
-        for (ai, bi) in a.iter().zip(b) {
-            self.connect(*ai, *bi);
-        }
-    }
-}
+pub use check_panic;
 
 pub fn verify_proof_tuple<
     F: RichField + Extendable<D>,
@@ -326,17 +325,20 @@ pub fn pack_and_compute_poseidon_target<F: HashableField + Extendable<D>, const
     b.hash_n_to_hash_no_pad::<H>(packed)
 }
 
-pub trait SelectHashBuilder {
+pub trait HashBuilder {
     /// Select `first_hash` or `second_hash` as output depending on the Boolean `cond`
     fn select_hash(
         &mut self,
         cond: BoolTarget,
         first_hash: &HashOutTarget,
         second_hash: &HashOutTarget,
     ) -> HashOutTarget;
+
+    /// Determine whether `first_hash == second_hash`
+    fn hash_eq(&mut self, first_hash: &HashOutTarget, second_hash: &HashOutTarget) -> BoolTarget;
 }
 
-impl<F: RichField + Extendable<D>, const D: usize> SelectHashBuilder for CircuitBuilder<F, D> {
+impl<F: RichField + Extendable<D>, const D: usize> HashBuilder for CircuitBuilder<F, D> {
     fn select_hash(
         &mut self,
         cond: BoolTarget,
@@ -352,6 +354,28 @@ impl<F: RichField + Extendable<D>, const D: usize> SelectHashBuilder for Circuit
                 .collect_vec(),
         )
     }
+
+    fn hash_eq(&mut self, first_hash: &HashOutTarget, second_hash: &HashOutTarget) -> BoolTarget {
+        let _true = self._true();
+        first_hash
+            .elements
+            .iter()
+            .zip(second_hash.elements.iter())
+            .fold(_true, |acc, (first, second)| {
+                let is_eq = self.is_equal(*first, *second);
+                self.and(acc, is_eq)
+            })
+    }
+}
+
+pub trait SelectTarget {
+    /// Return `first` if `cond` is true, `second` otherwise
+    fn select<F: SerializableRichField<D>, const D: usize>(
+        b: &mut CircuitBuilder<F, D>,
+        cond: &BoolTarget,
+        first: &Self,
+        second: &Self,
+    ) -> Self;
 }
 
 pub trait ToFields<F: RichField> {
@@ -414,10 +438,16 @@ impl<F: RichField> Fieldable<F> for u64 {
 }
 
 pub trait FromTargets {
+    /// Number of targets necessary to instantiate `Self`
+    const NUM_TARGETS: usize;
+
+    /// Number of targets in `t` must be at least `Self::NUM_TARGETS`
     fn from_targets(t: &[Target]) -> Self;
 }
 
 impl FromTargets for HashOutTarget {
+    const NUM_TARGETS: usize = NUM_HASH_OUT_ELTS;
+
     fn from_targets(t: &[Target]) -> Self {
         HashOutTarget {
             elements: create_array(|i| t[i]),

mp2-v1/src/api.rs

@@ -1,11 +1,12 @@
 //! Main APIs and related structures
 
-use std::iter::once;
+use std::{collections::BTreeSet, iter::once};
 
 use crate::{
     block_extraction,
     contract_extraction::{self, compute_metadata_digest as contract_metadata_digest},
     final_extraction,
+    indexing::ColumnID,
     length_extraction::{
         self, compute_metadata_digest as length_metadata_digest, LengthCircuitInput,
     },
@@ -20,11 +21,14 @@ use anyhow::Result;
 use itertools::Itertools;
 use mp2_common::{
     digest::Digest,
+    group_hashing::map_to_curve_point,
     poseidon::H,
     types::HashOutput,
     utils::{Fieldable, ToFields},
+    F,
 };
 use plonky2::{
+    field::types::Field,
     iop::target::Target,
     plonk::config::{GenericHashOut, Hasher},
 };
@@ -141,6 +145,9 @@ pub fn generate_proof(params: &PublicParameters, input: CircuitInput) -> Result<
                         length_circuit_set,
                     )
                 }
+                final_extraction::CircuitInput::NoProvable(input) => {
+                    params.final_extraction.generate_no_provable_proof(input)
+                }
             }
         }
         CircuitInput::CellsTree(input) => verifiable_db::api::generate_proof(
@@ -243,3 +250,36 @@ pub fn metadata_hash(
     // compute final hash
     combine_digest_and_block(contract_digest + value_digest)
 }
+
+// compute metadata digest for a table including no provable extraction data:
+// it corresponds to the digest of the column identifiers
+pub(crate) fn no_provable_metadata_digest<I: IntoIterator<Item = ColumnID>>(
+    column_ids: I,
+) -> Digest {
+    map_to_curve_point(
+        &column_ids
+            .into_iter()
+            .collect::<BTreeSet<_>>() // collect into a BTreeSet to ensure they are hashed
+            // in a deterministic order
+            .into_iter()
+            .map(F::from_canonical_u64)
+            .collect_vec(),
+    )
+}
+
+/// Compute the metadata hash for a table including no provable extraction data.
+/// The input is the set of the column identifiers of the table
+pub fn no_provable_metadata_hash<I: IntoIterator<Item = ColumnID>>(column_ids: I) -> MetadataHash {
+    let metadata_digest = no_provable_metadata_digest(column_ids);
+    // Add the prefix to the metadata digest to ensure the metadata digest
+    // will keep track of whether we use this dummy circuit or not.
+    // It's similar logic as the dummy circuit of final extraction.
+    let prefix = final_extraction::DUMMY_METADATA_DIGEST_PREFIX.to_fields();
+    let inputs = prefix
+        .into_iter()
+        .chain(metadata_digest.to_fields())
+        .collect_vec();
+    let digest = map_to_curve_point(&inputs);
+
+    combine_digest_and_block(digest)
+}