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(&[], &[])
             })
             .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(&[], &[], &[]);
     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, &[]);
     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 = &[];
     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, &[], &[]);
 
     Input {
         block_header_merkle_root: [2u8; 32],

crates/services/executor/src/executor.rs

@@ -504,7 +504,7 @@ where
 
         // Now that the transactions have been executed, generate the full header.
 
-        let block = block.generate(&message_ids[..]);
+        let block = block.generate(&message_ids[..], &events);
 
         let finalized_block_id = block.id();
 

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

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

crates/services/producer/src/mocks.rs

@@ -121,7 +121,7 @@ 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, &[], &[])
 }
 
 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(&[], &[])
             })
             .collect::<Vec<_>>();
 

crates/types/src/blockchain/block.rs

@@ -24,6 +24,7 @@ use crate::{
         ChainId,
         MessageId,
     },
+    services::executor::Event,
 };
 
 /// Version-able block type
@@ -86,9 +87,10 @@ impl Block<Transaction> {
         header: PartialBlockHeader,
         transactions: Vec<Transaction>,
         message_ids: &[MessageId],
+        events: &[Event],
     ) -> Self {
         let inner = BlockV1 {
-            header: header.generate(&transactions, message_ids),
+            header: header.generate(&transactions, message_ids, events),
             transactions,
         };
         Block::V1(inner)
@@ -218,8 +220,8 @@ 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], events: &[Event]) -> Block {
+        Block::new(self.header, self.transactions, message_ids, events)
     }
 }
 

crates/types/src/blockchain/header.rs

@@ -10,13 +10,15 @@ use super::{
 };
 use crate::{
     fuel_merkle,
+    fuel_merkle::binary::root_calculator::MerkleRootCalculator,
     fuel_tx::Transaction,
     fuel_types::{
         canonical::Serialize,
         BlockHeight,
         Bytes32,
         MessageId,
     },
+    services::executor::Event,
 };
 use tai64::Tai64;
 
@@ -195,7 +197,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 +369,31 @@ impl PartialBlockHeader {
         self,
         transactions: &[Transaction],
         message_ids: &[MessageId],
+        events: &[Event],
     ) -> 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();
+
+        // 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 application = ApplicationHeader {
             da_height: self.application.da_height,
@@ -387,7 +405,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 +451,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()

crates/types/src/entities/coins/coin.rs

@@ -2,6 +2,7 @@
 
 use crate::{
     fuel_asm::Word,
+    fuel_crypto,
     fuel_tx::{
         input::coin::{
             CoinPredicate,
@@ -14,6 +15,7 @@ use crate::{
     fuel_types::{
         Address,
         AssetId,
+        Bytes32,
     },
 };
 
@@ -44,6 +46,17 @@ impl Coin {
             tx_pointer: self.tx_pointer,
         })
     }
+
+    /// Hash the inner values of the coin into a single `Bytes32` hash.
+    pub fn hash(&self) -> Bytes32 {
+        let hasher = fuel_crypto::Hasher::default()
+            .chain(self.owner)
+            .chain(self.amount.to_be_bytes())
+            .chain(self.asset_id)
+            .chain(self.tx_pointer.block_height().to_be_bytes())
+            .chain(self.tx_pointer.tx_index().to_be_bytes());
+        hasher.finalize()
+    }
 }
 
 /// The compressed version of the `Coin` with minimum fields required for

crates/types/src/services/executor.rs

@@ -31,7 +31,10 @@ use crate::{
     },
     services::Uncommitted,
 };
-use std::error::Error as StdError;
+use std::{
+    error::Error as StdError,
+    ops::Deref,
+};
 
 /// The alias for executor result.
 pub type Result<T> = core::result::Result<T, Error>;
@@ -66,6 +69,18 @@ pub enum Event {
     CoinConsumed(Coin),
 }
 
+impl Event {
+    /// Get the hash of the internal values of the event.
+    pub fn hash(&self) -> Bytes32 {
+        match self {
+            Event::MessageImported(message) => (*message.id().deref()).into(),
+            Event::MessageConsumed(message) => (*message.id().deref()).into(),
+            Event::CoinCreated(coin) => coin.hash(),
+            Event::CoinConsumed(coin) => coin.hash(),
+        }
+    }
+}
+
 /// The status of a transaction after it is executed.
 #[derive(Debug, Clone)]
 pub struct TransactionExecutionStatus {