feat(l2): shared bridge forced inclusion

.github/workflows/pr-main_l1_l2_dev.yaml

@@ -67,12 +67,12 @@ jobs:
       - name: Show ENVs
         run: |
           cat .env
+          cp .env cmd/.env
 
       - name: Run test
         run: |
           cd crates/l2
           tail -n +1 -f /tmp/ethrex.log &
           tail -n +1 -f /tmp/prover.log &
-          export $(xargs < .env)
           PROPOSER_COINBASE_ADDRESS=0x0007a881CD95B1484fca47615B64803dad620C8d \
           cargo test l2 --release -- --nocapture --test-threads=1

cmd/ethrex/l2/command.rs

@@ -398,6 +398,8 @@ impl Command {
                 )
                 .await?;
 
+                let chain_id = store.get_chain_config().chain_id;
+
                 let rollup_store =
                     StoreRollup::new(&store_path.join("rollup_store"), rollup_store_type)?;
                 rollup_store
@@ -517,6 +519,7 @@ impl Command {
                         U256::from(batch_number),
                         None,
                         blobs_bundle,
+                        chain_id,
                     )
                     .await?;
 

cmd/ethrex/l2/deployer.rs

@@ -545,7 +545,7 @@ const INITIALIZE_ON_CHAIN_PROPOSER_SIGNATURE: &str = "initialize(bool,address,bo
 const INITIALIZE_BRIDGE_ADDRESS_SIGNATURE: &str = "initializeBridgeAddress(address)";
 const TRANSFER_OWNERSHIP_SIGNATURE: &str = "transferOwnership(address)";
 const ACCEPT_OWNERSHIP_SIGNATURE: &str = "acceptOwnership()";
-const BRIDGE_INITIALIZER_SIGNATURE: &str = "initialize(address,address,uint256,address)";
+const BRIDGE_INITIALIZER_SIGNATURE: &str = "initialize(address,address,uint256,address, uint256)";
 const ROUTER_INITIALIZER_SIGNATURE: &str = "initialize(address)";
 const ROUTER_REGISTER_SIGNATURE: &str = "register(uint256,address)";
 
@@ -1307,6 +1307,7 @@ async fn initialize_contracts(
             Value::Address(contract_addresses.on_chain_proposer_address),
             Value::Uint(opts.inclusion_max_wait.into()),
             Value::Address(contract_addresses.router.unwrap_or_default()),
+            Value::Uint(genesis.config.chain_id.into()),
         ];
         let bridge_initialization_calldata =
             encode_calldata(BRIDGE_INITIALIZER_SIGNATURE, &calldata_values)?;

crates/common/types/l2/balance_diff.rs

@@ -1,5 +1,5 @@
 use bytes::BufMut;
-use ethereum_types::U256;
+use ethereum_types::{H256, U256};
 use ethrex_rlp::{decode::RLPDecode, encode::RLPEncode, error::RLPDecodeError};
 use serde::{Deserialize, Serialize};
 
@@ -8,19 +8,29 @@ use serde::{Deserialize, Serialize};
 pub struct BalanceDiff {
     pub chain_id: U256,
     pub value: U256,
+    pub message_hashes: Vec<H256>,
 }
 
 impl RLPEncode for BalanceDiff {
     fn encode(&self, buf: &mut dyn BufMut) {
         self.chain_id.encode(buf);
         self.value.encode(buf);
+        self.message_hashes.encode(buf);
     }
 }
 
 impl RLPDecode for BalanceDiff {
     fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
         let (chain_id, rlp) = U256::decode_unfinished(rlp)?;
         let (value, rlp) = U256::decode_unfinished(rlp)?;
-        Ok((BalanceDiff { chain_id, value }, rlp))
+        let (message_hashes, rlp) = Vec::<H256>::decode_unfinished(rlp)?;
+        Ok((
+            BalanceDiff {
+                chain_id,
+                value,
+                message_hashes,
+            },
+            rlp,
+        ))
     }
 }

crates/common/types/l2/batch.rs

@@ -10,9 +10,9 @@ pub struct Batch {
     pub first_block: u64,
     pub last_block: u64,
     pub state_root: H256,
-    pub privileged_transactions_hash: H256,
-    pub l1_message_hashes: Vec<H256>,
-    pub l2_message_hashes: Vec<H256>,
+    pub l1_in_messages_rolling_hash: H256,
+    pub l2_in_message_rolling_hashes: Vec<(u64, H256)>,
+    pub l1_out_message_hashes: Vec<H256>,
     pub balance_diffs: Vec<BalanceDiff>,
     pub blobs_bundle: BlobsBundle,
     pub commit_tx: Option<H256>,

crates/common/types/transaction.rs

@@ -1523,6 +1523,7 @@ impl PrivilegedL2Transaction {
 
         Some(crate::utils::keccak(
             [
+                U256::from(self.chain_id).to_big_endian().as_ref(),
                 self.from.as_bytes(),
                 to.as_bytes(),
                 &nonce,

crates/l2/based/block_fetcher.rs

@@ -292,12 +292,14 @@ impl BlockFetcher {
         batch_number: U256,
         commit_tx: H256,
     ) -> Result<(), BlockFetcherError> {
+        let chain_id = self.store.get_chain_config().chain_id;
         let batch = get_batch(
             &self.store,
             batch,
             batch_number,
             Some(commit_tx),
             BlobsBundle::default(),
+            chain_id,
         )
         .await?;
 

crates/l2/common/src/messages.rs

@@ -85,18 +85,13 @@ pub fn get_block_l1_messages(receipts: &[Receipt]) -> Vec<L1Message> {
         .collect()
 }
 
-#[derive(Serialize, Deserialize, Debug)]
-pub struct L2MessageProof {
-    pub batch_number: u64,
-    pub message_hash: H256,
-    pub merkle_proof: Vec<H256>,
-}
-
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 /// Represents a message from the L2 to another L2
 pub struct L2Message {
     /// Chain id of the destination chain
-    pub chain_id: U256,
+    pub dest_chain_id: U256,
+    /// Chain id of the source chain
+    pub source_chain_id: u64,
     /// Address that originated the transaction
     pub from: Address,
     /// Address of the recipient in the destination chain
@@ -113,17 +108,19 @@ pub struct L2Message {
 
 impl L2Message {
     pub fn encode(&self) -> Vec<u8> {
-        let mut bytes = Vec::new();
-        bytes.extend_from_slice(&self.chain_id.to_big_endian());
-        bytes.extend_from_slice(&self.from.to_fixed_bytes());
-        bytes.extend_from_slice(&self.to.to_fixed_bytes());
-        bytes.extend_from_slice(&self.value.to_big_endian());
-        bytes.extend_from_slice(&self.gas_limit.to_big_endian());
-        bytes.extend_from_slice(&self.data);
-        bytes
+        [
+            U256::from(self.source_chain_id).to_big_endian().as_ref(),
+            self.from.as_bytes(),
+            self.to.as_bytes(),
+            &self.tx_id.to_big_endian(),
+            &self.value.to_big_endian(),
+            &self.gas_limit.to_big_endian(),
+            keccak(&self.data).as_bytes(),
+        ]
+        .concat()
     }
-    pub fn from_log(log: &ethrex_common::types::Log) -> Option<L2Message> {
-        let chain_id = U256::from_big_endian(&log.topics.get(1)?.0);
+    pub fn from_log(log: &ethrex_common::types::Log, source_chain_id: u64) -> Option<L2Message> {
+        let dest_chain_id = U256::from_big_endian(&log.topics.get(1)?.0);
         let from = H256::from_slice(log.data.get(0..32)?);
         let from = Address::from_slice(&from.as_fixed_bytes()[12..]);
         let to = H256::from_slice(log.data.get(32..64)?);
@@ -136,7 +133,8 @@ impl L2Message {
         let calldata = log.data.get(224..224 + calldata_len.as_usize())?;
 
         Some(L2Message {
-            chain_id,
+            dest_chain_id,
+            source_chain_id,
             from,
             to,
             value,
@@ -147,7 +145,7 @@ impl L2Message {
     }
 }
 
-pub fn get_block_l2_messages(receipts: &[Receipt]) -> Vec<L2Message> {
+pub fn get_block_l2_out_messages(receipts: &[Receipt], source_chain_id: u64) -> Vec<L2Message> {
     receipts
         .iter()
         .flat_map(|receipt| {
@@ -159,24 +157,28 @@ pub fn get_block_l2_messages(receipts: &[Receipt]) -> Vec<L2Message> {
                         && log.topics.first() == Some(&*L2MESSAGE_EVENT_SELECTOR)
                         && log.topics.len() >= 2 // need chainId
                 })
-                .filter_map(L2Message::from_log)
+                .filter_map(|log| L2Message::from_log(log, source_chain_id))
         })
         .collect()
 }
 
 pub fn get_balance_diffs(messages: &[L2Message]) -> Vec<BalanceDiff> {
     let mut balance_diffs: BTreeMap<U256, BalanceDiff> = BTreeMap::new();
     for message in messages {
+        let mut value = message.value;
         if message.to == BRIDGE_ADDRESS && message.from == BRIDGE_ADDRESS {
-            continue;
+            // This is the mint transaction, ignore the value
+            value = U256::zero();
         }
         let entry = balance_diffs
-            .entry(message.chain_id)
+            .entry(message.dest_chain_id)
             .or_insert(BalanceDiff {
-                chain_id: message.chain_id,
+                chain_id: message.dest_chain_id,
                 value: U256::zero(),
+                message_hashes: Vec::new(),
             });
-        entry.value += message.value;
+        entry.value += value;
+        entry.message_hashes.push(get_l2_message_hash(message));
     }
     balance_diffs.into_values().collect()
 }

crates/l2/common/src/privileged_transactions.rs

@@ -30,13 +30,14 @@ pub enum PrivilegedTransactionError {
     LengthTooLarge(#[from] std::num::TryFromIntError),
 }
 
-pub fn get_block_l1_privileged_transactions(
+pub fn get_block_l1_in_messages(
     txs: &[Transaction],
     chain_id: u64,
 ) -> Vec<PrivilegedL2Transaction> {
     txs.iter()
         .filter_map(|tx| {
             if let Transaction::PrivilegedL2Transaction(tx) = tx {
+                // The chain id of the L1-in message should match the chain id of the current chain
                 if tx.chain_id == chain_id {
                     return Some(tx.clone());
                 }
@@ -48,6 +49,25 @@ pub fn get_block_l1_privileged_transactions(
         .collect()
 }
 
+pub fn get_block_l2_in_messages(
+    txs: &[Transaction],
+    chain_id: u64,
+) -> Vec<PrivilegedL2Transaction> {
+    txs.iter()
+        .filter_map(|tx| {
+            if let Transaction::PrivilegedL2Transaction(tx) = tx {
+                // The chain id of the L2-in message is the chain id of the source chain
+                if tx.chain_id != chain_id {
+                    return Some(tx.clone());
+                }
+                None
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
 pub fn compute_privileged_transactions_hash(
     privileged_transaction_hashes: Vec<H256>,
 ) -> Result<H256, PrivilegedTransactionError> {