fix(l1): rlp decode impls for low size transactions (#5139)

**Motivation**

Transactions are encoded in the following format:

* Legacy:  rlp(Transaction) 
* Non Legacy: rlp(Payload) where Payload is a bytes object containing
(TxType || rlp(Transaction))

When decoding in order to differentiate between a legacy and a non
legacy transaction we check if the encoded data is a bytes object
(`is_encoded_as_bytes`) by checking if the prefix is between 0xb8 and
0xbf. The problem with this is that when encoding the payload the
0xb8..0xbf prefix is only applied if the length of the payload is higher
than 56 bytes. This is usually the case for most real-scenario
transactions, but if the transaction payload were to be lower than 56
bytes then we would not detect it as a bytes object and would attempt
and fail to decode the transaction as a legacy one.

This PR fixes this problem by:

* Changing the criteria for legacy vs non-legacy transactions to instead
check if the incoming encoded data is encoded as a list (if so it will
be legacy). Aka `is_encoded_as_bytes` -> `!is_encoded_as_list`
* Considering the case where the encoded payload doesn't have the bytes
prefix. Aka `get_rlp_bytes_item_payload` -> `decode_rlp_item`. The
latter which considers the prefix RLP_NULL+size that is used when
encoding less than 56 bytes

<!-- Why does this pull request exist? What are its goals? -->

**Description**
* Fix decoding for `Transaction` & `P2PTransaction` for cases where tx
payload encoding is less than 56 bytes
<!-- A clear and concise general description of the changes this PR
introduces -->

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #issue_number

Author: fmoletta

crates/common/types/receipt.rs

@@ -227,6 +227,8 @@ impl RLPDecode for ReceiptWithBloom {
     /// A) Legacy receipts: rlp(receipt)
     /// B) Non legacy receipts: rlp(Bytes(tx_type | rlp(receipt))).
     fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
+        // The minimum size for a ReceiptWithBloom is > 256 bytes (due to the Bloom type field) meaning that it is safe
+        // to check for bytes prefix to diferenticate between legacy receipts and non-legacy receipt payloads
         let (tx_type, rlp) = if is_encoded_as_bytes(rlp)? {
             let payload = get_rlp_bytes_item_payload(rlp)?;
             let tx_type = match payload.first().ok_or(RLPDecodeError::InvalidLength)? {

crates/common/types/transaction.rs

@@ -12,7 +12,7 @@ use sha3::{Digest, Keccak256};
 
 use ethrex_rlp::{
     constants::RLP_NULL,
-    decode::{RLPDecode, get_rlp_bytes_item_payload, is_encoded_as_bytes},
+    decode::{RLPDecode, decode_rlp_item},
     encode::{PayloadRLPEncode, RLPEncode},
     error::RLPDecodeError,
     structs::{Decoder, Encoder},
@@ -77,28 +77,27 @@ impl RLPEncode for P2PTransaction {
 
 impl RLPDecode for P2PTransaction {
     fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
-        if is_encoded_as_bytes(rlp)? {
-            // Adjust the encoding to get the payload
-            let payload = get_rlp_bytes_item_payload(rlp)?;
+        let (is_list, payload, remainder) = decode_rlp_item(rlp)?;
+        if !is_list {
             let tx_type = payload.first().ok_or(RLPDecodeError::InvalidLength)?;
             let tx_encoding = &payload.get(1..).ok_or(RLPDecodeError::InvalidLength)?;
             // Look at the first byte to check if it corresponds to a TransactionType
             match *tx_type {
                 // Legacy
-                0x0 => LegacyTransaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (P2PTransaction::LegacyTransaction(tx), rem)), // TODO: check if this is a real case scenario
+                0x0 => LegacyTransaction::decode(tx_encoding)
+                    .map(|tx| (P2PTransaction::LegacyTransaction(tx), remainder)), // TODO: check if this is a real case scenario
                 // EIP2930
-                0x1 => EIP2930Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (P2PTransaction::EIP2930Transaction(tx), rem)),
+                0x1 => EIP2930Transaction::decode(tx_encoding)
+                    .map(|tx| (P2PTransaction::EIP2930Transaction(tx), remainder)),
                 // EIP1559
-                0x2 => EIP1559Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (P2PTransaction::EIP1559Transaction(tx), rem)),
+                0x2 => EIP1559Transaction::decode(tx_encoding)
+                    .map(|tx| (P2PTransaction::EIP1559Transaction(tx), remainder)),
                 // EIP4844
-                0x3 => WrappedEIP4844Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (P2PTransaction::EIP4844TransactionWithBlobs(tx), rem)),
+                0x3 => WrappedEIP4844Transaction::decode(tx_encoding)
+                    .map(|tx| (P2PTransaction::EIP4844TransactionWithBlobs(tx), remainder)),
                 // EIP7702
-                0x4 => EIP7702Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (P2PTransaction::EIP7702Transaction(tx), rem)),
+                0x4 => EIP7702Transaction::decode(tx_encoding)
+                    .map(|tx| (P2PTransaction::EIP7702Transaction(tx), remainder)),
                 ty => Err(RLPDecodeError::Custom(format!(
                     "Invalid transaction type: {ty}"
                 ))),
@@ -406,31 +405,30 @@ impl RLPDecode for Transaction {
     /// B) Non legacy transactions: rlp(Bytes) where Bytes represents the canonical encoding for the transaction as a bytes object.
     /// Checkout [Transaction::decode_canonical] for more information
     fn decode_unfinished(rlp: &[u8]) -> Result<(Self, &[u8]), RLPDecodeError> {
-        if is_encoded_as_bytes(rlp)? {
-            // Adjust the encoding to get the payload
-            let payload = get_rlp_bytes_item_payload(rlp)?;
+        let (is_list, payload, remainder) = decode_rlp_item(rlp)?;
+        if !is_list {
             let tx_type = payload.first().ok_or(RLPDecodeError::InvalidLength)?;
             let tx_encoding = &payload.get(1..).ok_or(RLPDecodeError::InvalidLength)?;
             // Look at the first byte to check if it corresponds to a TransactionType
             match *tx_type {
                 // Legacy
-                0x0 => LegacyTransaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::LegacyTransaction(tx), rem)), // TODO: check if this is a real case scenario
+                0x0 => LegacyTransaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::LegacyTransaction(tx), remainder)), // TODO: check if this is a real case scenario
                 // EIP2930
-                0x1 => EIP2930Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::EIP2930Transaction(tx), rem)),
+                0x1 => EIP2930Transaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::EIP2930Transaction(tx), remainder)),
                 // EIP1559
-                0x2 => EIP1559Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::EIP1559Transaction(tx), rem)),
+                0x2 => EIP1559Transaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::EIP1559Transaction(tx), remainder)),
                 // EIP4844
-                0x3 => EIP4844Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::EIP4844Transaction(tx), rem)),
+                0x3 => EIP4844Transaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::EIP4844Transaction(tx), remainder)),
                 // EIP7702
-                0x4 => EIP7702Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::EIP7702Transaction(tx), rem)),
+                0x4 => EIP7702Transaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::EIP7702Transaction(tx), remainder)),
                 // PrivilegedL2
-                0x7e => PrivilegedL2Transaction::decode_unfinished(tx_encoding)
-                    .map(|(tx, rem)| (Transaction::PrivilegedL2Transaction(tx), rem)),
+                0x7e => PrivilegedL2Transaction::decode(tx_encoding)
+                    .map(|tx| (Transaction::PrivilegedL2Transaction(tx), remainder)),
                 ty => Err(RLPDecodeError::Custom(format!(
                     "Invalid transaction type: {ty}"
                 ))),
@@ -3131,4 +3129,12 @@ mod tests {
         assert_eq!(generic_tx.access_list[0].address, access_list[0].0);
         assert_eq!(generic_tx.access_list[0].storage_keys, access_list[0].1);
     }
+
+    #[test]
+    fn encode_decode_low_size_tx() {
+        let tx = Transaction::EIP2930Transaction(EIP2930Transaction::default());
+        let encoded = tx.encode_to_vec();
+        let decoded_tx = Transaction::decode(&encoded).unwrap();
+        assert_eq!(tx, decoded_tx);
+    }
 }