feat!: replace our header,body,receipt types with alloy types (#1721)

Author: KolbyML

Cargo.lock

@@ -36,7 +36,7 @@ rust-version = "1.85.0"
 version = "0.2.1"
 
 [workspace.dependencies]
-alloy = { version = "0.11.1", default-features = false, features = ["std"] }
+alloy = { version = "0.12", default-features = false, features = ["std"] }
 alloy-rlp = { version = "0.3.8", default-features = false, features = ["derive"] }
 anyhow = "1.0.68"
 async-trait = "0.1.68"

Cargo.toml

@@ -1,21 +1,22 @@
 use std::sync::Arc;
 
-use alloy::primitives::B256;
+use alloy::{
+    consensus::{BlockBody as AlloyBlockBody, Header},
+    eips::eip4895::Withdrawals,
+    primitives::B256,
+};
 use anyhow::{anyhow, bail};
 use ethportal_api::{
     types::{
         execution::{
             accumulator::EpochAccumulator,
-            block_body::{
-                BlockBody, BlockBodyLegacy, BlockBodyMerge, BlockBodyShanghai, MERGE_TIMESTAMP,
-                SHANGHAI_TIMESTAMP,
-            },
+            block_body::{BlockBody, MERGE_TIMESTAMP, SHANGHAI_TIMESTAMP},
             header_with_proof::{BlockHeaderProof, HeaderWithProof},
         },
         jsonrpc::{params::Params, request::JsonRequest},
     },
     utils::bytes::{hex_decode, hex_encode},
-    Header, HistoryContentKey, HistoryContentValue, Receipts,
+    HistoryContentKey, HistoryContentValue, Receipts,
 };
 use futures::future::join_all;
 use serde_json::{json, Value};
@@ -108,7 +109,7 @@ impl ExecutionApi {
         };
         // Construct header by hash content key / value pair.
         let header_by_hash_content_key =
-            HistoryContentKey::new_block_header_by_hash(full_header.header.hash());
+            HistoryContentKey::new_block_header_by_hash(full_header.header.hash_slow());
         // Construct header by number content key / value pair.
         let header_by_number_content_key =
             HistoryContentKey::new_block_header_by_number(full_header.header.number);
@@ -141,34 +142,46 @@ impl ExecutionApi {
     ) -> anyhow::Result<(HistoryContentKey, HistoryContentValue)> {
         let block_body = self.get_trusted_block_body(full_header).await?;
         block_body.validate_against_header(&full_header.header)?;
-        let content_key = HistoryContentKey::new_block_body(full_header.header.hash());
+        let content_key = HistoryContentKey::new_block_body(full_header.header.hash_slow());
         let content_value = HistoryContentValue::BlockBody(block_body);
         Ok((content_key, content_value))
     }
 
     /// Return an unvalidated block body for the given FullHeader.
     async fn get_trusted_block_body(&self, full_header: &FullHeader) -> anyhow::Result<BlockBody> {
-        let txs = full_header.txs.clone();
+        let transactions = full_header.txs.clone();
         if full_header.header.timestamp > SHANGHAI_TIMESTAMP {
             if !full_header.uncles.is_empty() {
                 bail!("Invalid block: Shanghai block contains uncles");
             }
             let withdrawals = match full_header.withdrawals.clone() {
-                Some(val) => val,
+                Some(val) => Some(Withdrawals(val)),
                 None => bail!("Invalid block: Shanghai block missing withdrawals"),
             };
-            Ok(BlockBody::Shanghai(BlockBodyShanghai { txs, withdrawals }))
+            Ok(BlockBody(AlloyBlockBody {
+                transactions,
+                ommers: vec![],
+                withdrawals,
+            }))
         } else if full_header.header.timestamp > MERGE_TIMESTAMP {
             if !full_header.uncles.is_empty() {
                 bail!("Invalid block: Merge block contains uncles");
             }
-            Ok(BlockBody::Merge(BlockBodyMerge { txs }))
+            Ok(BlockBody(AlloyBlockBody {
+                transactions,
+                ommers: vec![],
+                withdrawals: None,
+            }))
         } else {
-            let uncles = match full_header.uncles.len() {
+            let ommers = match full_header.uncles.len() {
                 0 => vec![],
                 _ => self.get_trusted_uncles(&full_header.uncles).await?,
             };
-            Ok(BlockBody::Legacy(BlockBodyLegacy { txs, uncles }))
+            Ok(BlockBody(AlloyBlockBody {
+                transactions,
+                ommers,
+                withdrawals: None,
+            }))
         }
     }
 
@@ -205,21 +218,19 @@ impl ExecutionApi {
     ) -> anyhow::Result<(HistoryContentKey, HistoryContentValue)> {
         // Build receipts
         let receipts = match full_header.txs.len() {
-            0 => Receipts {
-                receipt_list: vec![],
-            },
+            0 => Receipts(vec![]),
             _ => self.get_trusted_receipts(full_header.header.number).await?,
         };
 
         // Validate Receipts
-        let receipts_root = receipts.root()?;
+        let receipts_root = receipts.root();
         if receipts_root != full_header.header.receipts_root {
             bail!(
                 "Receipts root doesn't match header receipts root: {receipts_root:?} - {:?}",
                 full_header.header.receipts_root
             );
         }
-        let content_key = HistoryContentKey::new_block_receipts(full_header.header.hash());
+        let content_key = HistoryContentKey::new_block_receipts(full_header.header.hash_slow());
         let content_value = HistoryContentValue::Receipts(receipts);
         Ok((content_key, content_value))
     }

bin/portal-bridge/src/api/execution.rs

@@ -364,7 +364,7 @@ impl Era1Bridge {
         );
         let mut gossip_header_by_hash = true;
         if hunt {
-            let header_hash = block_tuple.header.header.hash();
+            let header_hash = block_tuple.header.header.hash_slow();
             let header_content_key = HistoryContentKey::new_block_header_by_hash(header_hash);
             let header_content_info = portal_client.get_content(header_content_key.clone()).await;
             if header_content_info.is_ok() {
@@ -456,7 +456,7 @@ impl Era1Bridge {
         }
         let mut gossip_body = true;
         if hunt {
-            let body_hash = block_tuple.header.header.hash();
+            let body_hash = block_tuple.header.header.hash_slow();
             let body_content_key = HistoryContentKey::new_block_body(body_hash);
             let body_content_info = portal_client.get_content(body_content_key.clone()).await;
             if body_content_info.is_ok() {
@@ -495,7 +495,7 @@ impl Era1Bridge {
         }
         let mut gossip_receipts = true;
         if hunt {
-            let receipts_hash = block_tuple.header.header.hash();
+            let receipts_hash = block_tuple.header.header.hash_slow();
             let receipts_content_key = HistoryContentKey::new_block_receipts(receipts_hash);
             let receipts_content_info = portal_client
                 .get_content(receipts_content_key.clone())
@@ -554,7 +554,7 @@ impl Era1Bridge {
         let header_record = &epoch_acc[header_index as usize];
 
         // Validate Header
-        let actual_header_hash = header.hash();
+        let actual_header_hash = header.hash_slow();
 
         ensure!(
             header_record.block_hash == actual_header_hash,
@@ -570,7 +570,7 @@ impl Era1Bridge {
         // Construct HistoryContentValue
         let content_value = HistoryContentValue::BlockHeaderWithProof(header_with_proof);
         // Construct HistoryContentKey for block header by hash and gossip it
-        let content_key = HistoryContentKey::new_block_header_by_hash(header.hash());
+        let content_key = HistoryContentKey::new_block_header_by_hash(header.hash_slow());
         gossip_history_content(portal_client, content_key, content_value, block_stats).await?;
 
         Ok(())
@@ -593,7 +593,7 @@ impl Era1Bridge {
         let header_record = &epoch_acc[header_index as usize];
 
         // Validate Header
-        let actual_header_hash = header.hash();
+        let actual_header_hash = header.hash_slow();
 
         ensure!(
             header_record.block_hash == actual_header_hash,
@@ -626,7 +626,7 @@ impl Era1Bridge {
         );
         let header = block_tuple.header.header;
         // Construct HistoryContentKey
-        let content_key = HistoryContentKey::new_block_body(header.hash());
+        let content_key = HistoryContentKey::new_block_body(header.hash_slow());
         // Construct HistoryContentValue
         let content_value = HistoryContentValue::BlockBody(block_tuple.body.body);
         gossip_history_content(portal_client, content_key, content_value, block_stats).await
@@ -643,7 +643,7 @@ impl Era1Bridge {
         );
         let header = block_tuple.header.header;
         // Construct HistoryContentKey
-        let content_key = HistoryContentKey::new_block_receipts(header.hash());
+        let content_key = HistoryContentKey::new_block_receipts(header.hash_slow());
         // Construct HistoryContentValue
         let content_value = HistoryContentValue::Receipts(block_tuple.receipts.receipts);
         gossip_history_content(portal_client, content_key, content_value, block_stats).await

bin/portal-bridge/src/bridge/era1.rs

@@ -268,7 +268,7 @@ impl StateBridge {
             .last_fetched_block()
             .await?
             .header
-            .hash();
+            .hash_slow();
 
         let walk_diff =
             TrieWalker::new_partial_trie(root_with_trie_diff.root, root_with_trie_diff.trie_diff)?;

bin/portal-bridge/src/bridge/state.rs

@@ -1,13 +1,12 @@
 use std::sync::Arc;
 
-use alloy::primitives::B256;
-use anyhow::{anyhow, ensure};
-use ethportal_api::types::execution::{
-    accumulator::EpochAccumulator,
-    header::{Header, TxHashes},
-    transaction::Transaction,
-    withdrawal::Withdrawal,
+use alloy::{
+    consensus::{Header, TxEnvelope},
+    eips::eip4895::Withdrawal,
+    primitives::B256,
 };
+use anyhow::{anyhow, ensure};
+use ethportal_api::types::execution::accumulator::EpochAccumulator;
 use serde::{Deserialize, Deserializer};
 use serde_json::Value;
 use trin_validation::constants::{EPOCH_SIZE, MERGE_BLOCK_NUMBER};
@@ -44,8 +43,8 @@ impl<'de> Deserialize<'de> for FullHeaderBatch {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FullHeader {
     pub header: Header,
-    pub txs: Vec<Transaction>,
-    pub tx_hashes: TxHashes,
+    pub txs: Vec<TxEnvelope>,
+    pub tx_hashes: Vec<B256>,
     pub uncles: Vec<B256>,
     pub epoch_acc: Option<Arc<EpochAccumulator>>,
     pub withdrawals: Option<Vec<Withdrawal>>,
@@ -59,8 +58,8 @@ impl TryFrom<Value> for FullHeader {
     fn try_from(val: Value) -> anyhow::Result<Self> {
         let header: Header = serde_json::from_value(val.clone())?;
         let uncles: Vec<B256> = serde_json::from_value(val["uncles"].clone())?;
-        let tx_hashes: TxHashes = serde_json::from_value(val["transactions"].clone())?;
-        let txs: Vec<Transaction> = serde_json::from_value(val["transactions"].clone())?;
+        let txs: Vec<TxEnvelope> = serde_json::from_value(val["transactions"].clone())?;
+        let tx_hashes: Vec<B256> = txs.iter().map(|tx| *tx.hash()).collect();
         let withdrawals = match val["withdrawals"].clone() {
             Value::Null => None,
             _ => serde_json::from_value(val["withdrawals"].clone())?,
@@ -90,7 +89,7 @@ impl FullHeader {
             let header_record = &epoch_acc[header_index as usize];
 
             // Validate Header
-            let actual_header_hash = self.header.hash();
+            let actual_header_hash = self.header.hash_slow();
 
             ensure!(
                 header_record.block_hash == actual_header_hash,
@@ -100,20 +99,19 @@ impl FullHeader {
             );
         }
         ensure!(
-            self.txs.len() == self.tx_hashes.hashes.len(),
+            self.txs.len() == self.tx_hashes.len(),
             "txs.len() != tx_hashes.hashes.len(): {} != {}",
             self.txs.len(),
-            self.tx_hashes.hashes.len()
+            self.tx_hashes.len()
         );
         Ok(())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use ethportal_api::types::execution::block_body::{
-        BlockBody, BlockBodyLegacy, BlockBodyShanghai,
-    };
+    use alloy::{consensus::BlockBody as AlloyBlockBody, eips::eip4895::Withdrawals};
+    use ethportal_api::types::execution::block_body::BlockBody;
     use serde_json::Value;
     use ssz::{Decode, Encode};
 
@@ -127,7 +125,7 @@ mod tests {
         let full_header = FullHeader::try_from(body["result"].clone()).unwrap();
         let header: Header = serde_json::from_value(body["result"].clone()).unwrap();
         assert_eq!(full_header.txs.len(), 19);
-        assert_eq!(full_header.tx_hashes.hashes.len(), 19);
+        assert_eq!(full_header.tx_hashes.len(), 19);
         assert_eq!(full_header.uncles.len(), 1);
         assert_eq!(full_header.header, header);
     }
@@ -138,9 +136,10 @@ mod tests {
             std::fs::read_to_string("../../test_assets/mainnet/block_17034871_value.json").unwrap();
         let body: Value = serde_json::from_str(&body).unwrap();
         let full_header = FullHeader::try_from(body["result"].clone()).unwrap();
-        let block_body = BlockBody::Shanghai(BlockBodyShanghai {
-            txs: full_header.txs.clone(),
-            withdrawals: full_header.withdrawals.unwrap(),
+        let block_body = BlockBody(AlloyBlockBody {
+            transactions: full_header.txs.clone(),
+            ommers: vec![],
+            withdrawals: full_header.withdrawals.map(Withdrawals),
         });
         let header: Header = serde_json::from_value(body["result"].clone()).unwrap();
         block_body.validate_against_header(&header).unwrap();
@@ -152,9 +151,10 @@ mod tests {
             std::fs::read_to_string("../../test_assets/mainnet/block_17034873_value.json").unwrap();
         let body: Value = serde_json::from_str(&body).unwrap();
         let full_header = FullHeader::try_from(body["result"].clone()).unwrap();
-        let block_body = BlockBody::Shanghai(BlockBodyShanghai {
-            txs: full_header.txs.clone(),
-            withdrawals: full_header.withdrawals.unwrap(),
+        let block_body = BlockBody(AlloyBlockBody {
+            transactions: full_header.txs.clone(),
+            ommers: vec![],
+            withdrawals: full_header.withdrawals.map(Withdrawals),
         });
         let header: Header = serde_json::from_value(body["result"].clone()).unwrap();
         block_body.validate_against_header(&header).unwrap();
@@ -172,9 +172,10 @@ mod tests {
         let body: Value = serde_json::from_str(&body).unwrap();
         let full_header = FullHeader::try_from(body["result"].clone()).unwrap();
         let header: Header = serde_json::from_value(body["result"].clone()).unwrap();
-        let block_body = BlockBody::Shanghai(BlockBodyShanghai {
-            txs: full_header.txs.clone(),
-            withdrawals: full_header.withdrawals.unwrap(),
+        let block_body = BlockBody(AlloyBlockBody {
+            transactions: full_header.txs.clone(),
+            ommers: vec![],
+            withdrawals: full_header.withdrawals.map(Withdrawals),
         });
         block_body.validate_against_header(&header).unwrap();
         // test ssz roundtrip
@@ -191,19 +192,23 @@ mod tests {
             std::fs::read_to_string("../../test_assets/geth_batch/headers.json").unwrap();
         let full_headers: FullHeaderBatch = serde_json::from_str(&expected).unwrap();
         for full_header in full_headers.headers {
-            let block_body = BlockBody::Legacy(BlockBodyLegacy {
-                txs: full_header.txs,
-                uncles: vec![],
+            let block_body = BlockBody(AlloyBlockBody {
+                transactions: full_header.txs,
+                ommers: vec![],
+                withdrawals: None,
             });
             // test that txs are properly deserialized if tx root is properly calculated
             assert_eq!(
-                block_body.transactions_root().unwrap(),
+                block_body.transactions_root(),
                 full_header.header.transactions_root
             );
             // this block has no uncles, aka an empty uncles root is calculated.
             // there's no need to validate deserialization of uncles, since they're just a
             // vector of Header, which are already tested above
-            assert_eq!(block_body.uncles_root(), full_header.header.uncles_hash);
+            assert_eq!(
+                block_body.calculate_ommers_root(),
+                full_header.header.ommers_hash
+            );
         }
     }
 }