feat: network-parameterized block responses

crates/network-primitives/src/lib.rs

@@ -7,7 +7,7 @@
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
 mod traits;
-pub use traits::{ReceiptResponse, TransactionResponse};
+pub use traits::{BlockResponse, HeaderResponse, ReceiptResponse, TransactionResponse};
 
 mod block;
 pub use block::{BlockTransactionHashes, BlockTransactions, BlockTransactionsKind};

crates/network-primitives/src/traits.rs

@@ -1,6 +1,8 @@
 use alloy_primitives::{Address, BlockHash, Bytes, TxHash, U256};
 use alloy_serde::WithOtherFields;
 
+use crate::BlockTransactions;
+
 /// Receipt JSON-RPC response.
 pub trait ReceiptResponse {
     /// Address of the created contract, or `None` if the transaction was not a deployment.
@@ -46,6 +48,44 @@ pub trait TransactionResponse {
     fn input(&self) -> &Bytes;
 }
 
+/// Header JSON-RPC response.
+pub trait HeaderResponse {
+    /// Hash of the block
+    fn hash(&self) -> Option<BlockHash>;
+
+    /// Block number
+    fn number(&self) -> Option<u64>;
+
+    /// Block timestamp
+    fn timestamp(&self) -> Option<u64>;
+
+    /// Extra data
+    fn extra_data(&self) -> &Bytes;
+
+    /// Base fee per unit of gas (If EIP-1559 is supported)
+    fn base_fee_per_gas(&self) -> Option<u128>;
+
+    /// Blob fee for the next block (if EIP-4844 is supported)
+    fn next_block_blob_fee(&self) -> Option<u128>;
+}
+
+/// Block JSON-RPC response.
+pub trait BlockResponse {
+    /// Header type
+    type Header;
+    /// Transaction type
+    type Transaction;
+
+    /// Block header
+    fn header(&self) -> &Self::Header;
+
+    /// Block transactions
+    fn transactions(&self) -> &BlockTransactions<Self::Transaction>;
+
+    /// Mutable reference to block transactions
+    fn transactions_mut(&mut self) -> &mut BlockTransactions<Self::Transaction>;
+}
+
 impl<T: TransactionResponse> TransactionResponse for WithOtherFields<T> {
     fn tx_hash(&self) -> TxHash {
         self.inner.tx_hash()
@@ -89,3 +129,46 @@ impl<T: ReceiptResponse> ReceiptResponse for WithOtherFields<T> {
         self.inner.block_number()
     }
 }
+
+impl<T: BlockResponse> BlockResponse for WithOtherFields<T> {
+    type Header = T::Header;
+    type Transaction = T::Transaction;
+
+    fn header(&self) -> &Self::Header {
+        self.inner.header()
+    }
+
+    fn transactions(&self) -> &BlockTransactions<Self::Transaction> {
+        self.inner.transactions()
+    }
+
+    fn transactions_mut(&mut self) -> &mut BlockTransactions<Self::Transaction> {
+        self.inner.transactions_mut()
+    }
+}
+
+impl<T: HeaderResponse> HeaderResponse for WithOtherFields<T> {
+    fn hash(&self) -> Option<BlockHash> {
+        self.inner.hash()
+    }
+
+    fn number(&self) -> Option<u64> {
+        self.inner.number()
+    }
+
+    fn timestamp(&self) -> Option<u64> {
+        self.inner.timestamp()
+    }
+
+    fn extra_data(&self) -> &Bytes {
+        self.inner.extra_data()
+    }
+
+    fn base_fee_per_gas(&self) -> Option<u128> {
+        self.inner.base_fee_per_gas()
+    }
+
+    fn next_block_blob_fee(&self) -> Option<u128> {
+        self.inner.next_block_blob_fee()
+    }
+}

crates/network/src/any/mod.rs

@@ -1,7 +1,7 @@
 use crate::Network;
 use alloy_consensus::TxType;
 use alloy_eips::eip2718::Eip2718Error;
-use alloy_rpc_types_eth::{AnyTransactionReceipt, Header, Transaction, TransactionRequest};
+use alloy_rpc_types_eth::{AnyTransactionReceipt, Block, Header, Transaction, TransactionRequest};
 use alloy_serde::WithOtherFields;
 use core::fmt;
 
@@ -73,5 +73,7 @@ impl Network for AnyNetwork {
 
     type ReceiptResponse = AnyTransactionReceipt;
 
-    type HeaderResponse = WithOtherFields<Header>;
+    type HeaderResponse = Header;
+
+    type BlockResponse = WithOtherFields<Block<Self::TransactionResponse>>;
 }

crates/network/src/ethereum/mod.rs

@@ -29,4 +29,6 @@ impl Network for Ethereum {
     type ReceiptResponse = alloy_rpc_types_eth::TransactionReceipt;
 
     type HeaderResponse = alloy_rpc_types_eth::Header;
+
+    type BlockResponse = alloy_rpc_types_eth::Block;
 }

crates/network/src/lib.rs

@@ -9,6 +9,7 @@
 use alloy_consensus::TxReceipt;
 use alloy_eips::eip2718::{Eip2718Envelope, Eip2718Error};
 use alloy_json_rpc::RpcObject;
+use alloy_network_primitives::{BlockResponse, HeaderResponse};
 use core::fmt::{Debug, Display};
 
 mod transaction;
@@ -85,5 +86,9 @@ pub trait Network: Debug + Clone + Copy + Sized + Send + Sync + 'static {
     type ReceiptResponse: RpcObject + ReceiptResponse;
 
     /// The JSON body of a header response.
-    type HeaderResponse: RpcObject;
+    type HeaderResponse: RpcObject + HeaderResponse;
+
+    /// The JSON body of a block response.
+    type BlockResponse: RpcObject
+        + BlockResponse<Transaction = Self::TransactionResponse, Header = Self::HeaderResponse>;
 }

crates/provider/src/fillers/gas.rs

@@ -8,6 +8,7 @@ use crate::{
 };
 use alloy_json_rpc::RpcError;
 use alloy_network::{Network, TransactionBuilder};
+use alloy_network_primitives::{BlockResponse, HeaderResponse};
 use alloy_rpc_types_eth::BlockNumberOrTag;
 use alloy_transport::{Transport, TransportResult};
 use futures::FutureExt;
@@ -150,7 +151,7 @@ impl GasFiller {
                         .get_block_by_number(BlockNumberOrTag::Latest, false)
                         .await?
                         .ok_or(RpcError::NullResp)?
-                        .header
+                        .header()
                         .next_block_blob_fee()
                         .ok_or(RpcError::UnsupportedFeature("eip4844"))
                 }

crates/provider/src/provider/trait.rs

@@ -9,15 +9,17 @@ use crate::{
 use alloy_eips::eip2718::Encodable2718;
 use alloy_json_rpc::{RpcError, RpcParam, RpcReturn};
 use alloy_network::{Ethereum, Network};
-use alloy_network_primitives::{BlockTransactionsKind, ReceiptResponse};
+use alloy_network_primitives::{
+    BlockResponse, BlockTransactionsKind, HeaderResponse, ReceiptResponse,
+};
 use alloy_primitives::{
     hex, Address, BlockHash, BlockNumber, Bytes, StorageKey, StorageValue, TxHash, B256, U128,
     U256, U64,
 };
 use alloy_rpc_client::{ClientRef, PollerBuilder, RpcCall, WeakClient};
 use alloy_rpc_types_eth::{
-    AccessListResult, Block, BlockId, BlockNumberOrTag, EIP1186AccountProofResponse, FeeHistory,
-    Filter, FilterChanges, Log, SyncStatus,
+    AccessListResult, BlockId, BlockNumberOrTag, EIP1186AccountProofResponse, FeeHistory, Filter,
+    FilterChanges, Log, SyncStatus,
 };
 use alloy_transport::{BoxTransport, Transport, TransportResult};
 use serde_json::value::RawValue;
@@ -213,8 +215,8 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
                 self.get_block_by_number(BlockNumberOrTag::Latest, false)
                     .await?
                     .ok_or(RpcError::NullResp)?
-                    .header
-                    .base_fee_per_gas
+                    .header()
+                    .base_fee_per_gas()
                     .ok_or(RpcError::UnsupportedFeature("eip1559"))?
             }
         };
@@ -262,7 +264,7 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
         &self,
         block: BlockId,
         kind: BlockTransactionsKind,
-    ) -> TransportResult<Option<Block>> {
+    ) -> TransportResult<Option<N::BlockResponse>> {
         match block {
             BlockId::Hash(hash) => self.get_block_by_hash(hash.into(), kind).await,
             BlockId::Number(number) => {
@@ -277,21 +279,21 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
         &self,
         hash: BlockHash,
         kind: BlockTransactionsKind,
-    ) -> TransportResult<Option<Block>> {
+    ) -> TransportResult<Option<N::BlockResponse>> {
         let full = match kind {
             BlockTransactionsKind::Full => true,
             BlockTransactionsKind::Hashes => false,
         };
 
         let block = self
             .client()
-            .request::<_, Option<Block>>("eth_getBlockByHash", (hash, full))
+            .request::<_, Option<N::BlockResponse>>("eth_getBlockByHash", (hash, full))
             .await?
             .map(|mut block| {
                 if !full {
                     // this ensures an empty response for `Hashes` has the expected form
                     // this is required because deserializing [] is ambiguous
-                    block.transactions.convert_to_hashes();
+                    block.transactions_mut().convert_to_hashes();
                 }
                 block
             });
@@ -305,16 +307,16 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
         &self,
         number: BlockNumberOrTag,
         hydrate: bool,
-    ) -> TransportResult<Option<Block>> {
+    ) -> TransportResult<Option<N::BlockResponse>> {
         let block = self
             .client()
-            .request::<_, Option<Block>>("eth_getBlockByNumber", (number, hydrate))
+            .request::<_, Option<N::BlockResponse>>("eth_getBlockByNumber", (number, hydrate))
             .await?
             .map(|mut block| {
                 if !hydrate {
                     // this ensures an empty response for `Hashes` has the expected form
                     // this is required because deserializing [] is ambiguous
-                    block.transactions.convert_to_hashes();
+                    block.transactions_mut().convert_to_hashes();
                 }
                 block
             });
@@ -548,7 +550,7 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
     }
 
     /// Gets an uncle block through the tag [BlockId] and index [u64].
-    async fn get_uncle(&self, tag: BlockId, idx: u64) -> TransportResult<Option<Block>> {
+    async fn get_uncle(&self, tag: BlockId, idx: u64) -> TransportResult<Option<N::BlockResponse>> {
         let idx = U64::from(idx);
         match tag {
             BlockId::Hash(hash) => {
@@ -725,7 +727,9 @@ pub trait Provider<T: Transport + Clone = BoxTransport, N: Network = Ethereum>:
     /// # }
     /// ```
     #[cfg(feature = "pubsub")]
-    async fn subscribe_blocks(&self) -> TransportResult<alloy_pubsub::Subscription<Block>> {
+    async fn subscribe_blocks(
+        &self,
+    ) -> TransportResult<alloy_pubsub::Subscription<N::BlockResponse>> {
         self.root().pubsub_frontend()?;
         let id = self.client().request("eth_subscribe", ("newHeads",)).await?;
         self.root().get_subscription(id).await
@@ -1007,7 +1011,7 @@ mod tests {
     use alloy_network::AnyNetwork;
     use alloy_node_bindings::Anvil;
     use alloy_primitives::{address, b256, bytes, keccak256};
-    use alloy_rpc_types_eth::request::TransactionRequest;
+    use alloy_rpc_types_eth::{request::TransactionRequest, Block};
 
     fn init_tracing() {
         let _ = tracing_subscriber::fmt::try_init();

crates/rpc-types-eth/src/block.rs

@@ -1,7 +1,7 @@
 //! Block RPC types.
 
 use crate::{ConversionError, Transaction, Withdrawal};
-use alloy_network_primitives::BlockTransactions;
+use alloy_network_primitives::{BlockResponse, BlockTransactions, HeaderResponse};
 use alloy_primitives::{Address, BlockHash, Bloom, Bytes, B256, B64, U256};
 use serde::{ser::Error, Deserialize, Serialize, Serializer};
 use std::{collections::BTreeMap, ops::Deref};
@@ -201,6 +201,32 @@ impl TryFrom<Header> for alloy_consensus::Header {
     }
 }
 
+impl HeaderResponse for Header {
+    fn hash(&self) -> Option<BlockHash> {
+        self.hash
+    }
+
+    fn number(&self) -> Option<u64> {
+        self.number
+    }
+
+    fn timestamp(&self) -> Option<u64> {
+        Some(self.timestamp)
+    }
+
+    fn extra_data(&self) -> &Bytes {
+        &self.extra_data
+    }
+
+    fn base_fee_per_gas(&self) -> Option<u128> {
+        self.base_fee_per_gas
+    }
+
+    fn next_block_blob_fee(&self) -> Option<u128> {
+        self.next_block_blob_fee()
+    }
+}
+
 /// Error that can occur when converting other types to blocks
 #[derive(Clone, Copy, Debug, thiserror::Error)]
 pub enum BlockError {
@@ -312,6 +338,23 @@ pub struct BlockOverrides {
     pub block_hash: Option<BTreeMap<u64, B256>>,
 }
 
+impl<T> BlockResponse for Block<T> {
+    type Transaction = T;
+    type Header = Header;
+
+    fn header(&self) -> &Self::Header {
+        &self.header
+    }
+
+    fn transactions(&self) -> &BlockTransactions<T> {
+        &self.transactions
+    }
+
+    fn transactions_mut(&mut self) -> &mut BlockTransactions<Self::Transaction> {
+        &mut self.transactions
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloy_primitives::keccak256;