feat(l1): implement eth/69 (#2860)

### **Motivation**

A new version of the eth protocol has been released (eth/69) and some
clients are supporting both eth/68 and eth/69 at the same time. We need
a way of being able to encode/decode the msg from both versions of the
protocol. Also, we need a way to remove easily the old version when it
becomes deprecated.

The new version includes changes in the status and receipts messages and
a new message RangeBlockUpdate.

### **Description**

A new file structure was created to accommodate the new implementation:
crates/networking/p2p/rlpx/eth/
crates/networking/p2p/rlpx/eth/eth68/ -> (status.rs and receipt.rs)
crates/networking/p2p/rlpx/eth/eth69/ -> (status.rs and receipt.rs)

In the new eth/69 protocol the messages status and receipts have been
changed, so a new intermediate structure was created to address this.
The encode for each version is decided by the type of the inner struct,
but the decode is not that straight forward as we don't know what
version of msg we received.

For the status msg was easier, as we received the eth version inside the
msg we can decide which version of the protocol we are using.

For the receipt msg, the only difference is the bloom field. A new
function `has_bloom` has been implemented to detect when a msg have the
bloom field to process it as a eth/68. The newer eth/69 receipts msg
won't have the bloom field (it can be calculated from the logs).

Also, as the new structure is a proxy to the different version of the
structure some new getters were needed.

The new msg BlockRangeUpdate was introduced with eth/69. This message
includes the earliest block available, the latest block available and
the its hash. This messages is been send once every epoch (aprox 6
mins).

In some places, the `receipts` need to be encoded using the _bloom_
field to validate the receipt_root of a block header. The function
encode_inner_with_bloom was used for these cases.

### **Future improvements**

- We're not using the received `BlockRangeUpdate` message, we can use
this information to discard peers quickly.
- The function `has_bloom` probably could be improved or at least not
use private decode functions.
- As mentioned before, this implementation is made with the assumption
that eth/68 is going to be deprecated in the future.
- We are currently not running the latest version of hive that includes
the

Closes #2805  & #2785

References:
[EIP-7642](https://eips.ethereum.org/EIPS/eip-7642#rationale)
[geth
implementation](ethereum/go-ethereum#29158)
[eth/69](https://github.com/ethereum/devp2p/blob/master/caps/eth.md)

Author: Mechanix97

Cargo.lock

@@ -513,7 +513,7 @@ pub fn decode_bytes(data: &[u8]) -> Result<(&[u8], &[u8]), RLPDecodeError> {
 /// Pads a slice of bytes with zeros on the left to make it a fixed size slice.
 /// The size of the data must be less than or equal to the size of the output array.
 #[inline]
-pub(crate) fn static_left_pad<const N: usize>(data: &[u8]) -> Result<[u8; N], RLPDecodeError> {
+pub fn static_left_pad<const N: usize>(data: &[u8]) -> Result<[u8; N], RLPDecodeError> {
     let mut result = [0; N];
 
     if data.is_empty() {

crates/common/rlp/decode.rs

@@ -248,7 +248,7 @@ impl<T: RLPEncode> RLPEncode for Vec<T> {
     }
 }
 
-pub(crate) fn encode_length(total_len: usize, buf: &mut dyn BufMut) {
+pub fn encode_length(total_len: usize, buf: &mut dyn BufMut) {
     if total_len < 56 {
         buf.put_u8(0xc0 + total_len as u8);
     } else {

crates/common/rlp/encode.rs

@@ -15,6 +15,8 @@ pub enum RLPDecodeError {
     UnexpectedString,
     #[error("InvalidCompression")]
     InvalidCompression(#[from] snap::Error),
+    #[error("IncompatibleProtocol")]
+    IncompatibleProtocol,
     #[error("{0}")]
     Custom(String),
 }

crates/common/rlp/error.rs

@@ -256,7 +256,7 @@ pub fn compute_receipts_root(receipts: &[Receipt]) -> H256 {
     let iter = receipts
         .iter()
         .enumerate()
-        .map(|(idx, receipt)| (idx.encode_to_vec(), receipt.encode_inner()));
+        .map(|(idx, receipt)| (idx.encode_to_vec(), receipt.encode_inner_with_bloom()));
     Trie::compute_hash_from_unsorted_iter(iter)
 }
 

crates/common/types/block.rs

@@ -17,11 +17,106 @@ pub struct Receipt {
     pub tx_type: TxType,
     pub succeeded: bool,
     pub cumulative_gas_used: u64,
-    pub bloom: Bloom,
     pub logs: Vec<Log>,
 }
 
 impl Receipt {
+    pub fn new(tx_type: TxType, succeeded: bool, cumulative_gas_used: u64, logs: Vec<Log>) -> Self {
+        Self {
+            tx_type,
+            succeeded,
+            cumulative_gas_used,
+            logs,
+        }
+    }
+
+    pub fn encode_inner(&self) -> Vec<u8> {
+        let mut encoded_data = vec![];
+        let tx_type: u8 = self.tx_type as u8;
+        Encoder::new(&mut encoded_data)
+            .encode_field(&tx_type)
+            .encode_field(&self.succeeded)
+            .encode_field(&self.cumulative_gas_used)
+            .encode_field(&self.logs)
+            .finish();
+        encoded_data
+    }
+
+    pub fn encode_inner_with_bloom(&self) -> Vec<u8> {
+        let mut encode_buff = match self.tx_type {
+            TxType::Legacy => {
+                vec![]
+            }
+            _ => {
+                vec![self.tx_type as u8]
+            }
+        };
+        let bloom = bloom_from_logs(&self.logs);
+        Encoder::new(&mut encode_buff)
+            .encode_field(&self.succeeded)
+            .encode_field(&self.cumulative_gas_used)
+            .encode_field(&bloom)
+            .encode_field(&self.logs)
+            .finish();
+        encode_buff
+    }
+}
+
+pub fn bloom_from_logs(logs: &[Log]) -> Bloom {
+    let mut bloom = Bloom::zero();
+    for log in logs {
+        bloom.accrue(BloomInput::Raw(log.address.as_ref()));
+        for topic in log.topics.iter() {
+            bloom.accrue(BloomInput::Raw(topic.as_ref()));
+        }
+    }
+    bloom
+}
+
+impl RLPEncode for Receipt {
+    fn encode(&self, buf: &mut dyn bytes::BufMut) {
+        let encoded_inner = self.encode_inner();
+        buf.put_slice(&encoded_inner);
+    }
+}
+
+impl RLPDecode for Receipt {
+    fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
+        let decoder = Decoder::new(rlp)?;
+        let (tx_type, decoder): (u8, _) = decoder.decode_field("tx-type")?;
+        let (succeeded, decoder) = decoder.decode_field("succeeded")?;
+        let (cumulative_gas_used, decoder) = decoder.decode_field("cumulative_gas_used")?;
+        let (logs, decoder) = decoder.decode_field("logs")?;
+
+        let Some(tx_type) = TxType::from_u8(tx_type) else {
+            return Err(RLPDecodeError::Custom(
+                "Invalid transaction type".to_string(),
+            ));
+        };
+
+        Ok((
+            Receipt {
+                tx_type,
+                succeeded,
+                cumulative_gas_used,
+                logs,
+            },
+            decoder.finish()?,
+        ))
+    }
+}
+
+/// Result of a transaction
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
+pub struct ReceiptWithBloom {
+    pub tx_type: TxType,
+    pub succeeded: bool,
+    pub cumulative_gas_used: u64,
+    pub bloom: Bloom,
+    pub logs: Vec<Log>,
+}
+
+impl ReceiptWithBloom {
     pub fn new(tx_type: TxType, succeeded: bool, cumulative_gas_used: u64, logs: Vec<Log>) -> Self {
         Self {
             tx_type,
@@ -31,6 +126,7 @@ impl Receipt {
             logs,
         }
     }
+
     // By reading the typed transactions EIP, and some geth code:
     // - https://eips.ethereum.org/EIPS/eip-2718
     // - https://github.com/ethereum/go-ethereum/blob/330190e476e2a2de4aac712551629a4134f802d5/core/types/receipt.go#L143
@@ -69,7 +165,7 @@ impl Receipt {
     /// Decodes Receipts in the following formats:
     /// A) Legacy receipts: rlp(receipt)
     /// B) Non legacy receipts: tx_type | rlp(receipt).
-    pub fn decode_inner(rlp: &[u8]) -> Result<Receipt, RLPDecodeError> {
+    pub fn decode_inner(rlp: &[u8]) -> Result<Self, RLPDecodeError> {
         // Obtain TxType
         let (tx_type, rlp) = match rlp.first() {
             Some(tx_type) if *tx_type < 0x7f => {
@@ -97,7 +193,7 @@ impl Receipt {
         let (logs, decoder) = decoder.decode_field("logs")?;
         decoder.finish()?;
 
-        Ok(Receipt {
+        Ok(Self {
             tx_type,
             succeeded,
             cumulative_gas_used,
@@ -107,18 +203,7 @@ impl Receipt {
     }
 }
 
-fn bloom_from_logs(logs: &[Log]) -> Bloom {
-    let mut bloom = Bloom::zero();
-    for log in logs {
-        bloom.accrue(BloomInput::Raw(log.address.as_ref()));
-        for topic in log.topics.iter() {
-            bloom.accrue(BloomInput::Raw(topic.as_ref()));
-        }
-    }
-    bloom
-}
-
-impl RLPEncode for Receipt {
+impl RLPEncode for ReceiptWithBloom {
     /// Receipts can be encoded in the following formats:
     /// A) Legacy receipts: rlp(receipt)
     /// B) Non legacy receipts: rlp(Bytes(tx_type | rlp(receipt))).
@@ -137,7 +222,7 @@ impl RLPEncode for Receipt {
     }
 }
 
-impl RLPDecode for Receipt {
+impl RLPDecode for ReceiptWithBloom {
     /// Receipts can be encoded in the following formats:
     /// A) Legacy receipts: rlp(receipt)
     /// B) Non legacy receipts: rlp(Bytes(tx_type | rlp(receipt))).
@@ -169,7 +254,7 @@ impl RLPDecode for Receipt {
         let (logs, decoder) = decoder.decode_field("logs")?;
 
         Ok((
-            Receipt {
+            ReceiptWithBloom {
                 tx_type,
                 succeeded,
                 cumulative_gas_used,
@@ -181,6 +266,29 @@ impl RLPDecode for Receipt {
     }
 }
 
+impl From<&Receipt> for ReceiptWithBloom {
+    fn from(receipt: &Receipt) -> Self {
+        Self {
+            tx_type: receipt.tx_type,
+            succeeded: receipt.succeeded,
+            cumulative_gas_used: receipt.cumulative_gas_used,
+            bloom: bloom_from_logs(&receipt.logs),
+            logs: receipt.logs.clone(),
+        }
+    }
+}
+
+impl From<&ReceiptWithBloom> for Receipt {
+    fn from(receipt: &ReceiptWithBloom) -> Self {
+        Self {
+            tx_type: receipt.tx_type,
+            succeeded: receipt.succeeded,
+            cumulative_gas_used: receipt.cumulative_gas_used,
+            logs: receipt.logs.clone(),
+        }
+    }
+}
+
 /// Data record produced during the execution of a transaction.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Log {
@@ -224,7 +332,6 @@ mod test {
             tx_type: TxType::Legacy,
             succeeded: true,
             cumulative_gas_used: 1200,
-            bloom: Bloom::random(),
             logs: vec![Log {
                 address: Address::random(),
                 topics: vec![],
@@ -241,7 +348,6 @@ mod test {
             tx_type: TxType::EIP4844,
             succeeded: true,
             cumulative_gas_used: 1500,
-            bloom: Bloom::random(),
             logs: vec![Log {
                 address: Address::random(),
                 topics: vec![],
@@ -251,10 +357,9 @@ mod test {
         let encoded_receipt = receipt.encode_to_vec();
         assert_eq!(receipt, Receipt::decode(&encoded_receipt).unwrap())
     }
-
     #[test]
     fn test_encode_decode_inner_receipt_legacy() {
-        let receipt = Receipt {
+        let receipt = ReceiptWithBloom {
             tx_type: TxType::Legacy,
             succeeded: true,
             cumulative_gas_used: 1200,
@@ -266,12 +371,15 @@ mod test {
             }],
         };
         let encoded_receipt = receipt.encode_inner();
-        assert_eq!(receipt, Receipt::decode_inner(&encoded_receipt).unwrap())
+        assert_eq!(
+            receipt,
+            ReceiptWithBloom::decode_inner(&encoded_receipt).unwrap()
+        )
     }
 
     #[test]
     fn test_encode_decode_receipt_inner_non_legacy() {
-        let receipt = Receipt {
+        let receipt = ReceiptWithBloom {
             tx_type: TxType::EIP4844,
             succeeded: true,
             cumulative_gas_used: 1500,
@@ -283,6 +391,9 @@ mod test {
             }],
         };
         let encoded_receipt = receipt.encode_inner();
-        assert_eq!(receipt, Receipt::decode_inner(&encoded_receipt).unwrap())
+        assert_eq!(
+            receipt,
+            ReceiptWithBloom::decode_inner(&encoded_receipt).unwrap()
+        )
     }
 }

crates/common/types/receipt.rs

@@ -11,7 +11,7 @@ ethrex-blockchain.workspace = true
 ethrex-rlp.workspace = true
 ethrex-storage.workspace = true
 ethrex-trie.workspace = true
-
+ethereum-types.workspace = true
 tracing.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true

crates/networking/p2p/Cargo.toml

@@ -17,7 +17,7 @@ use crate::{
             blocks::{
                 BlockBodies, BlockHeaders, GetBlockBodies, GetBlockHeaders, BLOCK_HEADER_LIMIT,
             },
-            receipts::{GetReceipts, Receipts},
+            receipts::GetReceipts,
         },
         message::Message as RLPxMessage,
         p2p::{Capability, SUPPORTED_ETH_CAPABILITIES, SUPPORTED_SNAP_CAPABILITIES},
@@ -280,10 +280,11 @@ impl PeerHandler {
             if let Some(receipts) = tokio::time::timeout(PEER_REPLY_TIMEOUT, async move {
                 loop {
                     match receiver.recv().await {
-                        Some(RLPxMessage::Receipts(Receipts { id, receipts }))
-                            if id == request_id =>
-                        {
-                            return Some(receipts)
+                        Some(RLPxMessage::Receipts(receipts)) => {
+                            if receipts.get_id() == request_id {
+                                return Some(receipts.get_receipts());
+                            }
+                            return None;
                         }
                         // Ignore replies that don't match the expected id (such as late responses)
                         Some(_) => continue,