feat: add eth_getFinalizeBlock/Header api (#24)

Author: chee-chyuan

crates/cli/commands/src/db/get.rs

@@ -2,8 +2,8 @@ use alloy_primitives::{hex, BlockHash};
 use clap::Parser;
 use reth_db::{
     static_file::{
-        AccountChangesetMask, ColumnSelectorOne, ColumnSelectorTwo, HeaderWithHashMask,
-        ReceiptMask, TransactionMask, TransactionSenderMask,
+        AccountChangesetMask, HeaderWithHashMask, ReceiptMask, TransactionMask,
+        TransactionSenderMask,
     },
     RawDupSort,
 };
@@ -122,30 +122,30 @@ impl Command {
                     StaticFileSegment::Headers => (
                         table_key::<tables::Headers>(&key)?,
                         None,
-                        <HeaderWithHashMask<HeaderTy<N>> as ColumnSelectorTwo>::MASK,
+                        <HeaderWithHashMask<HeaderTy<N>>>::MASK,
                     ),
                     StaticFileSegment::Transactions => (
                         table_key::<tables::Transactions>(&key)?,
                         None,
-                        <TransactionMask<TxTy<N>> as ColumnSelectorOne>::MASK,
+                        <TransactionMask<TxTy<N>>>::MASK,
                     ),
                     StaticFileSegment::Receipts => (
                         table_key::<tables::Receipts>(&key)?,
                         None,
-                        <ReceiptMask<ReceiptTy<N>> as ColumnSelectorOne>::MASK,
+                        <ReceiptMask<ReceiptTy<N>>>::MASK,
                     ),
                     StaticFileSegment::TransactionSenders => (
                         table_key::<tables::TransactionSenders>(&key)?,
                         None,
-                        <TransactionSenderMask as ColumnSelectorOne>::MASK,
+                        TransactionSenderMask::MASK,
                     ),
                     StaticFileSegment::AccountChangeSets => {
                         let subkey =
                             table_subkey::<tables::AccountChangeSets>(subkey.as_deref()).ok();
                         (
                             table_key::<tables::AccountChangeSets>(&key)?,
                             subkey,
-                            <AccountChangesetMask as ColumnSelectorOne>::MASK,
+                            AccountChangesetMask::MASK,
                         )
                     }
                     StaticFileSegment::StorageChangeSets => {

crates/rpc/rpc-convert/src/custom_header.rs

@@ -1,7 +1,7 @@
 //! Custom RPC header types with additional fields
 
 use alloy_network::primitives::HeaderResponse;
-use alloy_primitives::{BlockHash, U256};
+use alloy_primitives::{BlockHash, B256, U256};
 
 /// Custom RPC header that extends the standard header with additional fields
 #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]

crates/rpc/rpc-eth-api/src/core.rs

@@ -254,6 +254,25 @@ pub trait EthApi<
     #[method(name = "getHeaderByHash")]
     async fn header_by_hash(&self, hash: B256) -> RpcResult<Option<H>>;
 
+    /// Returns the finalized block header.
+    ///
+    /// The `verified_validator_num` parameter is provided for BSC compatibility but is not used
+    /// in standard Ethereum. The finalized block is determined by the Beacon Chain consensus
+    /// (Casper FFG) and requires 2/3+ validator attestations.
+    #[method(name = "getFinalizedHeader")]
+    async fn finalized_header(&self, verified_validator_num: u64) -> RpcResult<Option<H>>;
+
+    /// Returns the finalized block.
+    ///
+    /// The `verified_validator_num` parameter is provided for BSC compatibility but is not used
+    /// in standard Ethereum. The finalized block is determined by the Beacon Chain consensus
+    /// (Casper FFG) and requires 2/3+ validator attestations.
+    ///
+    /// If `full` is true, the block object will contain all transaction objects,
+    /// otherwise it will only contain the transaction hashes.
+    #[method(name = "getFinalizedBlock")]
+    async fn finalized_block(&self, verified_validator_num: u64, full: bool) -> RpcResult<Option<B>>;
+
     /// `eth_simulateV1` executes an arbitrary number of transactions on top of the requested state.
     /// The transactions are packed into individual blocks. Overrides can be provided.
     #[method(name = "simulateV1")]
@@ -776,6 +795,18 @@ where
         Ok(EthBlocks::rpc_block_header(self, hash.into()).await?)
     }
 
+    /// Handler for: `eth_getFinalizedHeader`
+    async fn finalized_header(&self, verified_validator_num: u64) -> RpcResult<Option<RpcHeader<T::NetworkTypes>>> {
+        trace!(target: "rpc::eth", verified_validator_num, "Serving eth_getFinalizedHeader");
+        Ok(EthBlocks::rpc_finalized_header(self, verified_validator_num).await?)
+    }
+
+    /// Handler for: `eth_getFinalizedBlock`
+    async fn finalized_block(&self, verified_validator_num: u64, full: bool) -> RpcResult<Option<RpcBlock<T::NetworkTypes>>> {
+        trace!(target: "rpc::eth", verified_validator_num, ?full, "Serving eth_getFinalizedBlock");
+        Ok(EthBlocks::rpc_finalized_block(self, verified_validator_num, full).await?)
+    }
+
     /// Handler for: `eth_simulateV1`
     async fn simulate_v1(
         &self,

crates/rpc/rpc-eth-api/src/helpers/block.rs

@@ -6,7 +6,7 @@ use crate::{
     RpcReceipt,
 };
 use alloy_consensus::{transaction::TxHashRef, TxReceipt};
-use alloy_eips::BlockId;
+use alloy_eips::{BlockId, BlockNumberOrTag};
 use alloy_rlp::Encodable;
 use alloy_rpc_types_eth::{Block, BlockTransactions, Index};
 use futures::Future;
@@ -74,6 +74,46 @@ pub trait EthBlocks: LoadBlock<RpcConvert: RpcConvert<Primitives = Self::Primiti
         }
     }
 
+    /// Returns the finalized block header.
+    ///
+    /// The `verified_validator_num` parameter is provided for BSC compatibility but is ignored
+    /// in the implementation. In standard Ethereum, the finalized block is determined by the
+    /// Beacon Chain consensus (Casper FFG).
+    fn rpc_finalized_header(
+        &self,
+        _verified_validator_num: u64,
+    ) -> impl Future<Output = Result<Option<RpcHeader<Self::NetworkTypes>>, Self::Error>> + Send
+    where
+        Self: FullEthApiTypes,
+    {
+        async move {
+            // Simply delegate to rpc_block_header with Finalized tag
+            self.rpc_block_header(BlockNumberOrTag::Finalized.into()).await
+        }
+    }
+
+    /// Returns the finalized block.
+    ///
+    /// The `verified_validator_num` parameter is provided for BSC compatibility but is ignored
+    /// in the implementation. In standard Ethereum, the finalized block is determined by the
+    /// Beacon Chain consensus (Casper FFG).
+    ///
+    /// If `full` is true, the block object will contain all transaction objects, otherwise it will
+    /// only contain the transaction hashes.
+    fn rpc_finalized_block(
+        &self,
+        _verified_validator_num: u64,
+        full: bool,
+    ) -> impl Future<Output = Result<Option<RpcBlock<Self::NetworkTypes>>, Self::Error>> + Send
+    where
+        Self: FullEthApiTypes,
+    {
+        async move {
+            // Simply delegate to rpc_block with Finalized tag
+            self.rpc_block(BlockNumberOrTag::Finalized.into(), full).await
+        }
+    }
+
     /// Returns the number transactions in the given block.
     ///
     /// Returns `None` if the block does not exist