Keep record of events from L1 in Block Header

CHANGELOG.md

@@ -21,6 +21,7 @@ Description of the upcoming release here.
 ### Changed
 
 #### Breaking
+- [#1769](https://github.com/FuelLabs/fuel-core/pull/1769): Include new field on header for the merkle root of imported events. Rename other message root field.
 - [#1768](https://github.com/FuelLabs/fuel-core/pull/1768): Moved `ContractsInfo` table to the off-chain database. Removed `salt` field from the `ContractConfig`.
 - [#1761](https://github.com/FuelLabs/fuel-core/pull/1761): Adjustments to the upcoming testnet configs:
   - Decreased the max size of the contract/predicate/script to be 100KB.

crates/fuel-core/src/database/block.rs

@@ -166,7 +166,7 @@ mod tests {
                     },
                 };
                 let block = PartialFuelBlock::new(header, vec![]);
-                block.generate(&[])
+                block.generate(&[], Default::default())
             })
             .collect::<Vec<_>>();
 

crates/fuel-core/src/executor.rs

@@ -1,5 +1,6 @@
 #[allow(clippy::arithmetic_side_effects)]
 #[allow(clippy::cast_possible_truncation)]
+#[allow(non_snake_case)]
 #[cfg(test)]
 mod tests {
     use crate as fuel_core;
@@ -2953,6 +2954,7 @@ mod tests {
             },
             StorageAsMut,
         };
+        use fuel_core_types::fuel_merkle::binary::root_calculator::MerkleRootCalculator;
 
         fn database_with_genesis_block(da_block_height: u64) -> Database<OnChain> {
             let mut db = Database::default();
@@ -3099,6 +3101,41 @@ mod tests {
             Ok(())
         }
 
+        #[test]
+        fn execute_without_commit__block_producer_includes_correct_inbox_event_merkle_root(
+        ) {
+            // given
+            let genesis_da_height = 3u64;
+            let on_chain_db = database_with_genesis_block(genesis_da_height);
+            let mut relayer_db = Database::<Relayer>::default();
+            let block_height = 1u32;
+            let relayer_da_height = 10u64;
+            let mut root_calculator = MerkleRootCalculator::new();
+            for da_height in (genesis_da_height + 1)..=relayer_da_height {
+                let mut message = Message::default();
+                message.set_da_height(da_height.into());
+                message.set_nonce(da_height.into());
+                root_calculator.push(message.id().as_ref());
+                add_message_to_relayer(&mut relayer_db, message);
+            }
+            let producer = create_relayer_executor(on_chain_db, relayer_db);
+            let block = test_block(block_height.into(), relayer_da_height.into(), 0);
+
+            // when
+            let (result, _) = producer
+                .execute_without_commit(
+                    ExecutionTypes::Production(block.into()),
+                    Default::default(),
+                )
+                .unwrap()
+                .into();
+
+            // then
+            let expected = root_calculator.root().into();
+            let actual = result.block.header().application().event_inbox_root;
+            assert_eq!(actual, expected);
+        }
+
         #[test]
         fn block_producer_does_not_take_messages_for_the_same_height() {
             let genesis_da_height = 1u64;

crates/fuel-core/src/query/message/test.rs

@@ -141,7 +141,7 @@ async fn can_build_message_proof() {
             generated: Default::default(),
         },
     }
-    .generate(&[], &[]);
+    .generate(&[], &[], Default::default());
     let commit_block = CompressedBlock::test(commit_block_header, vec![]);
     let message_block_header = PartialBlockHeader {
         application: ApplicationHeader {
@@ -157,7 +157,7 @@ async fn can_build_message_proof() {
             generated: Default::default(),
         },
     }
-    .generate(&[], &message_ids);
+    .generate(&[], &message_ids, Default::default());
     let message_block = CompressedBlock::test(message_block_header, TXNS.to_vec());
 
     let block_proof = MerkleProof {
@@ -213,8 +213,8 @@ async fn can_build_message_proof() {
     .unwrap()
     .unwrap();
     assert_eq!(
-        proof.message_block_header.message_receipt_root,
-        message_block.header().message_receipt_root
+        proof.message_block_header.message_outbox_root,
+        message_block.header().message_outbox_root
     );
     assert_eq!(
         proof.message_block_header.height(),

crates/fuel-core/src/schema/block.rs

@@ -165,7 +165,7 @@ impl Header {
 
     /// Merkle root of message receipts in this block.
     async fn message_receipt_root(&self) -> Bytes32 {
-        self.0.message_receipt_root.into()
+        self.0.message_outbox_root.into()
     }
 
     /// Fuel block height.

crates/fuel-core/src/service/genesis.rs

@@ -158,6 +158,9 @@ fn cleanup_genesis_progress(
 pub fn create_genesis_block(config: &Config) -> Block {
     let block_height = config.state_reader.block_height();
     let da_block_height = config.state_reader.da_block_height();
+    let transactions = vec![];
+    let message_ids = &[];
+    let events = Default::default();
     Block::new(
         PartialBlockHeader {
             application: ApplicationHeader::<Empty> {
@@ -171,17 +174,15 @@ pub fn create_genesis_block(config: &Config) -> Block {
                 generated: Empty,
             },
             consensus: ConsensusHeader::<Empty> {
-                // The genesis is a first block, so previous root is zero.
                 prev_root: Bytes32::zeroed(),
-                // The block height at genesis.
                 height: block_height,
                 time: fuel_core_types::tai64::Tai64::UNIX_EPOCH,
                 generated: Empty,
             },
         },
-        // Genesis block doesn't have any transaction.
-        vec![],
-        &[],
+        transactions,
+        message_ids,
+        events,
     )
 }
 

crates/services/consensus_module/poa/src/verifier/tests.rs

@@ -36,7 +36,7 @@ fn correct() -> Input {
             ..Default::default()
         },
     };
-    let block_header = partial_header.generate(&txs, &[]);
+    let block_header = partial_header.generate(&txs, &[], Default::default());
 
     Input {
         block_header_merkle_root: [2u8; 32],

crates/services/executor/src/executor.rs

@@ -53,6 +53,7 @@ use fuel_core_types::{
         RegId,
         Word,
     },
+    fuel_merkle::binary::root_calculator::MerkleRootCalculator,
     fuel_tx::{
         field::{
             InputContract,
@@ -304,6 +305,7 @@ pub struct ExecutionData {
     events: Vec<ExecutorEvent>,
     changes: Changes,
     pub skipped_transactions: Vec<(TxId, ExecutorError)>,
+    event_inbox_root: Bytes32,
 }
 
 /// Per-block execution options
@@ -499,12 +501,13 @@ where
             skipped_transactions,
             events,
             changes,
+            event_inbox_root,
             ..
         } = execution_data;
 
         // Now that the transactions have been executed, generate the full header.
 
-        let block = block.generate(&message_ids[..]);
+        let block = block.generate(&message_ids[..], event_inbox_root);
 
         let finalized_block_id = block.id();
 
@@ -557,6 +560,7 @@ where
             events: Vec::new(),
             changes: Default::default(),
             skipped_transactions: Vec::new(),
+            event_inbox_root: Default::default(),
         };
         let execution_data = &mut data;
 
@@ -724,13 +728,37 @@ where
             return Err(ExecutorError::DaHeightExceededItsLimit)
         };
 
+        // // Generate the message merkle root.
+        // let message_outbox_root = message_ids
+        //     .iter()
+        //     .fold(MerkleRootCalculator::new(), |mut tree, id| {
+        //         tree.push(id.as_ref());
+        //         tree
+        //     })
+        //     .root()
+        //     .into();
+        //
+        // // Generate the inbound event merkle root.
+        // let event_inbox_root = events
+        //     .iter()
+        //     .map(|event| event.hash())
+        //     .fold(MerkleRootCalculator::new(), |mut tree, event| {
+        //         tree.push(event.as_ref());
+        //         tree
+        //     })
+        //     .root()
+        //     .into();
+
+        let mut root_calculator = MerkleRootCalculator::new();
+
         for da_height in next_unprocessed_da_height..=header.da_height.0 {
             let da_height = da_height.into();
             let events = self
                 .relayer
                 .get_events(&da_height)
                 .map_err(|err| ExecutorError::RelayerError(err.into()))?;
             for event in events {
+                root_calculator.push(event.hash().as_ref());
                 match event {
                     Event::Message(message) => {
                         if message.da_height() != da_height {
@@ -747,6 +775,8 @@ where
             }
         }
 
+        execution_data.event_inbox_root = root_calculator.root().into();
+
         Ok(())
     }
 

crates/services/producer/src/block_producer/tests.rs

@@ -120,7 +120,7 @@ mod produce_and_execute_block_txpool {
             },
             transactions: vec![],
         }
-        .generate(&[])
+        .generate(&[], Default::default())
         .compress(&Default::default());
 
         let db = MockDb {
@@ -162,7 +162,7 @@ mod produce_and_execute_block_txpool {
             },
             transactions: vec![],
         }
-        .generate(&[])
+        .generate(&[], Default::default())
         .compress(&Default::default());
 
         // Given
@@ -215,7 +215,7 @@ mod produce_and_execute_block_txpool {
             },
             transactions: vec![],
         }
-        .generate(&[])
+        .generate(&[], Default::default())
         .compress(&Default::default());
 
         // Given
@@ -284,7 +284,7 @@ mod produce_and_execute_block_txpool {
             },
             transactions: vec![],
         }
-        .generate(&[])
+        .generate(&[], Default::default())
         .compress(&Default::default());
 
         let db = MockDb {

crates/services/producer/src/mocks.rs

@@ -121,7 +121,12 @@ fn to_block(component: &Components<Vec<ArcPoolTx>>) -> Block {
         .into_iter()
         .map(|tx| tx.as_ref().into())
         .collect();
-    Block::new(component.header_to_produce.clone(), transactions, &[])
+    Block::new(
+        component.header_to_produce.clone(),
+        transactions,
+        &[],
+        Default::default(),
+    )
 }
 
 impl Executor<Vec<ArcPoolTx>> for MockExecutor {

crates/storage/src/structured_storage/blocks.rs

@@ -100,7 +100,7 @@ mod tests {
                     },
                 };
                 let block = PartialFuelBlock::new(header, vec![]);
-                block.generate(&[])
+                block.generate(&[], Default::default())
             })
             .collect::<Vec<_>>();
 

crates/types/src/blockchain/block.rs

@@ -21,6 +21,7 @@ use crate::{
         UniqueIdentifier,
     },
     fuel_types::{
+        Bytes32,
         ChainId,
         MessageId,
     },
@@ -86,9 +87,10 @@ impl Block<Transaction> {
         header: PartialBlockHeader,
         transactions: Vec<Transaction>,
         message_ids: &[MessageId],
+        event_inbox_root: Bytes32,
     ) -> Self {
         let inner = BlockV1 {
-            header: header.generate(&transactions, message_ids),
+            header: header.generate(&transactions, message_ids, event_inbox_root),
             transactions,
         };
         Block::V1(inner)
@@ -218,8 +220,13 @@ impl PartialFuelBlock {
     ///
     /// Message ids are produced by executed the transactions and collecting
     /// the ids from the receipts of messages outputs.
-    pub fn generate(self, message_ids: &[MessageId]) -> Block {
-        Block::new(self.header, self.transactions, message_ids)
+    pub fn generate(self, message_ids: &[MessageId], event_inbox_root: Bytes32) -> Block {
+        Block::new(
+            self.header,
+            self.transactions,
+            message_ids,
+            event_inbox_root,
+        )
     }
 }
 

crates/types/src/blockchain/header.rs

@@ -10,6 +10,7 @@ use super::{
 };
 use crate::{
     fuel_merkle,
+    fuel_merkle::binary::root_calculator::MerkleRootCalculator,
     fuel_tx::Transaction,
     fuel_types::{
         canonical::Serialize,
@@ -195,7 +196,9 @@ pub struct GeneratedApplicationFields {
     /// Merkle root of transactions.
     pub transactions_root: Bytes32,
     /// Merkle root of message receipts in this block.
-    pub message_receipt_root: Bytes32,
+    pub message_outbox_root: Bytes32,
+    /// Root hash of all imported events from L1
+    pub event_inbox_root: Bytes32,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -365,17 +368,20 @@ impl PartialBlockHeader {
         self,
         transactions: &[Transaction],
         message_ids: &[MessageId],
+        event_inbox_root: Bytes32,
     ) -> BlockHeader {
         // Generate the transaction merkle root.
         let transactions_root = generate_txns_root(transactions);
 
         // Generate the message merkle root.
-        let mut message_tree =
-            fuel_merkle::binary::root_calculator::MerkleRootCalculator::new();
-        for id in message_ids {
-            message_tree.push(id.as_ref());
-        }
-        let message_receipt_root = message_tree.root().into();
+        let message_outbox_root = message_ids
+            .iter()
+            .fold(MerkleRootCalculator::new(), |mut tree, id| {
+                tree.push(id.as_ref());
+                tree
+            })
+            .root()
+            .into();
 
         let application = ApplicationHeader {
             da_height: self.application.da_height,
@@ -387,7 +393,8 @@ impl PartialBlockHeader {
                 transactions_count: transactions.len() as u64,
                 message_receipt_count: message_ids.len() as u64,
                 transactions_root,
-                message_receipt_root,
+                message_outbox_root,
+                event_inbox_root,
             },
         };
 
@@ -432,7 +439,7 @@ impl ApplicationHeader<GeneratedApplicationFields> {
         hasher.input(self.transactions_count.to_be_bytes());
         hasher.input(self.message_receipt_count.to_be_bytes());
         hasher.input(self.transactions_root.as_ref());
-        hasher.input(self.message_receipt_root.as_ref());
+        hasher.input(self.message_outbox_root.as_ref());
         hasher.input(self.consensus_parameters_version.to_bytes().as_slice());
         hasher.input(self.state_transition_bytecode_version.to_bytes().as_slice());
         hasher.digest()