fix: add single and mapping struct to integration test for generic extraction (Part 4)

mp2-common/src/eth.rs

@@ -12,6 +12,7 @@ use anyhow::{bail, Result};
 use eth_trie::{EthTrie, MemoryDB, Trie};
 use ethereum_types::H256;
 use itertools::Itertools;
+use log::debug;
 use log::warn;
 use rlp::Rlp;
 use serde::{Deserialize, Serialize};
@@ -214,6 +215,10 @@ impl StorageSlot {
                     .checked_add(U256::from(*evm_offset))
                     .unwrap()
                     .to_be_bytes();
+                debug!(
+                    "Storage slot struct: parent_location = {}, evm_offset = {}",
+                    parent_location, evm_offset,
+                );
                 B256::from_slice(&location)
             }
         }
@@ -237,6 +242,9 @@ impl StorageSlot {
     }
 }
 impl ProofQuery {
+    pub fn new(contract: Address, slot: StorageSlot) -> Self {
+        Self { contract, slot }
+    }
     pub fn new_simple_slot(address: Address, slot: usize) -> Self {
         Self {
             contract: address,
@@ -256,8 +264,14 @@ impl ProofQuery {
     ) -> Result<EIP1186AccountProofResponse> {
         // Query the MPT proof with retries.
         for i in 0..RETRY_NUM {
+            let location = self.slot.location();
+            debug!(
+                "Querying MPT proof:\n\tslot = {:?}, location = {:?}",
+                self.slot,
+                U256::from_be_slice(location.as_slice()),
+            );
             match provider
-                .get_proof(self.contract, vec![self.slot.location()])
+                .get_proof(self.contract, vec![location])
                 .block_id(block.into())
                 .await
             {

mp2-common/src/types.rs

@@ -112,6 +112,12 @@ impl From<HashOut<F>> for HashOutput {
     }
 }
 
+impl From<&HashOut<F>> for HashOutput {
+    fn from(value: &HashOut<F>) -> Self {
+        value.to_bytes().try_into().unwrap()
+    }
+}
+
 impl From<HashOutput> for HashOut<F> {
     fn from(value: HashOutput) -> Self {
         Self::from_bytes(&value.0)

mp2-v1/src/api.rs

@@ -21,6 +21,7 @@ use crate::{
 use alloy::primitives::Address;
 use anyhow::Result;
 use itertools::Itertools;
+use log::debug;
 use mp2_common::{
     digest::Digest,
     group_hashing::map_to_curve_point,
@@ -209,15 +210,12 @@ pub enum SlotInputs {
     MappingWithLength(Vec<SlotInput>, u8),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub struct SlotInput {
     /// Slot information of the variable
     pub(crate) slot: u8,
     /// The offset in bytes where to extract this column in a given EVM word
     pub(crate) byte_offset: usize,
-    /// The starting offset in `byte_offset` of the bits to be extracted for this column.
-    /// The column bits will start at `byte_offset * 8 + bit_offset`.
-    pub(crate) bit_offset: usize,
     /// The length (in bits) of the field to extract in the EVM word
     pub(crate) length: usize,
     /// At which EVM word is this column extracted from. For simple variables,
@@ -229,30 +227,19 @@ pub struct SlotInput {
 impl From<&ColumnInfo> for SlotInput {
     fn from(column_info: &ColumnInfo) -> Self {
         let slot = u8::try_from(column_info.slot.to_canonical_u64()).unwrap();
-        let [byte_offset, bit_offset, length] = [
-            column_info.byte_offset,
-            column_info.bit_offset,
-            column_info.length,
-        ]
-        .map(|f| usize::try_from(f.to_canonical_u64()).unwrap());
+        let [byte_offset, length] = [column_info.byte_offset, column_info.length]
+            .map(|f| usize::try_from(f.to_canonical_u64()).unwrap());
         let evm_word = u32::try_from(column_info.evm_word.to_canonical_u64()).unwrap();
 
-        SlotInput::new(slot, byte_offset, bit_offset, length, evm_word)
+        SlotInput::new(slot, byte_offset, length, evm_word)
     }
 }
 
 impl SlotInput {
-    pub fn new(
-        slot: u8,
-        byte_offset: usize,
-        bit_offset: usize,
-        length: usize,
-        evm_word: u32,
-    ) -> Self {
+    pub fn new(slot: u8, byte_offset: usize, length: usize, evm_word: u32) -> Self {
         Self {
             slot,
             byte_offset,
-            bit_offset,
             length,
             evm_word,
         }
@@ -266,10 +253,6 @@ impl SlotInput {
         self.byte_offset
     }
 
-    pub fn bit_offset(&self) -> usize {
-        self.bit_offset
-    }
-
     pub fn length(&self) -> usize {
         self.length
     }
@@ -338,7 +321,7 @@ fn value_metadata<const MAX_COLUMNS: usize, const MAX_FIELD_PER_EVM: usize>(
 }
 
 /// Compute the table information for the value columns.
-fn compute_table_info(
+pub fn compute_table_info(
     inputs: Vec<SlotInput>,
     address: &Address,
     chain_id: u64,
@@ -353,7 +336,7 @@ fn compute_table_info(
                 input.slot,
                 id,
                 input.byte_offset,
-                input.bit_offset,
+                0, // bit_offset
                 input.length,
                 input.evm_word,
             )
@@ -438,8 +421,16 @@ pub fn metadata_hash<const MAX_COLUMNS: usize, const MAX_FIELD_PER_EVM: usize>(
         chain_id,
         extra,
     );
+    // Correspond to the computation of final extraction base circuit.
+    let value_digest = map_to_curve_point(&value_digest.to_fields());
     // add contract digest
     let contract_digest = contract_metadata_digest(contract_address);
+    debug!(
+        "METADATA_HASH ->\n\tvalues_ext_md = {:?}\n\tcontract_md = {:?}\n\tfinal_ex_md(contract + values_ex) = {:?}",
+        value_digest.to_weierstrass(),
+        contract_digest.to_weierstrass(),
+        (contract_digest + value_digest).to_weierstrass(),
+    );
     // compute final hash
     combine_digest_and_block(contract_digest + value_digest)
 }

mp2-v1/src/final_extraction/api.rs

@@ -202,7 +202,9 @@ impl CircuitInput {
         Ok(Self::MergeTable(MergeCircuitInput {
             base,
             is_table_a_multiplier: true,
-            table_a_dimension: TableDimension::Single,
+            // TODO: May delete `TableDimension::Single`, we don't compute the wrapping digest for
+            // single dimension, otherwise the final digest is different with the block tree digest.
+            table_a_dimension: TableDimension::Compound,
             table_b_dimension: TableDimension::Compound,
         }))
     }

mp2-v1/src/final_extraction/public_inputs.rs

@@ -6,7 +6,7 @@ use mp2_common::{
     public_inputs::{PublicInputCommon, PublicInputRange},
     types::{CBuilder, CURVE_TARGET_LEN},
     u256::{self, UInt256Target},
-    utils::{FromFields, FromTargets, ToTargets},
+    utils::{FromFields, FromTargets, ToTargets, TryIntoBool},
     F,
 };
 use plonky2::iop::target::{BoolTarget, Target};
@@ -110,6 +110,10 @@ impl PublicInputs<'_, F> {
     pub fn block_number(&self) -> u64 {
         U256::from_fields(self.bn).to()
     }
+    /// Get the merge flag
+    pub fn merge_flag(&self) -> bool {
+        self.merge[0].try_into_bool().unwrap()
+    }
 }
 
 impl<'a, T> PublicInputs<'a, T> {

mp2-v1/src/indexing/row.rs

@@ -201,6 +201,9 @@ impl<PrimaryIndex: std::fmt::Debug + Clone + Default + PartialEq + Eq> RowPayloa
         }
     }
 
+    pub fn column_value(&self, column_id: ColumnID) -> Option<U256> {
+        self.cells.get(&column_id).map(|c| c.value)
+    }
     pub fn secondary_index_value(&self) -> U256 {
         self.cells
             .get(&self.secondary_index_column)