feat: Include missing block id in error responses

Fixes #7368.

crates/rpc/rpc/src/eth/api/call.rs

@@ -68,16 +68,11 @@ where
     pub async fn call(
         &self,
         request: TransactionRequest,
-        block_number: Option<BlockId>,
+        block_id: Option<BlockId>,
         overrides: EvmOverrides,
     ) -> EthResult<Bytes> {
-        let (res, _env) = self
-            .transact_call_at(
-                request,
-                block_number.unwrap_or(BlockId::Number(BlockNumberOrTag::Latest)),
-                overrides,
-            )
-            .await?;
+        let block_id = block_id.unwrap_or(BlockId::Number(BlockNumberOrTag::Latest));
+        let (res, _env) = self.transact_call_at(request, block_id, overrides).await?;
 
         ensure_success(res.result)
     }
@@ -376,10 +371,10 @@ where
     pub(crate) async fn create_access_list_at(
         &self,
         request: TransactionRequest,
-        block_number: Option<BlockId>,
+        block_id: Option<BlockId>,
     ) -> EthResult<AccessListWithGasUsed> {
         self.on_blocking_task(|this| async move {
-            this.create_access_list_with(request, block_number).await
+            this.create_access_list_with(request, block_id).await
         })
         .await
     }

crates/rpc/rpc/src/eth/api/mod.rs

@@ -22,7 +22,8 @@ use reth_primitives::{
     U256, U64,
 };
 use reth_provider::{
-    BlockReaderIdExt, ChainSpecProvider, EvmEnvProvider, StateProviderBox, StateProviderFactory,
+    BlockReaderIdExt, ChainSpecProvider, EvmEnvProvider, ProviderError, StateProviderBox,
+    StateProviderFactory,
 };
 use reth_rpc_types::{SyncInfo, SyncStatus};
 use reth_tasks::{pool::BlockingTaskPool, TaskSpawner, TokioTaskExecutor};
@@ -231,7 +232,11 @@ where
     ///
     /// Note: if not [BlockNumberOrTag::Pending] then this will only return canonical state. See also <https://github.com/paradigmxyz/reth/issues/4515>
     pub fn state_at_block_id(&self, at: BlockId) -> EthResult<StateProviderBox> {
-        Ok(self.provider().state_by_block_id(at)?)
+        self.provider().state_by_block_id(at).map_err(|e| match e {
+            ProviderError::HeaderNotFound(_) => EthApiError::UnknownBlockId(at),
+            ProviderError::BlockHashNotFound(_) => EthApiError::UnknownBlockId(at),
+            _ => e.into(),
+        })
     }
 
     /// Returns the state at the given [BlockId] enum or the latest.

crates/rpc/rpc/src/eth/api/server.rs

@@ -293,10 +293,10 @@ where
     async fn create_access_list(
         &self,
         request: TransactionRequest,
-        block_number: Option<BlockId>,
+        block_id: Option<BlockId>,
     ) -> Result<AccessListWithGasUsed> {
-        trace!(target: "rpc::eth", ?request, ?block_number, "Serving eth_createAccessList");
-        let access_list_with_gas_used = self.create_access_list_at(request, block_number).await?;
+        trace!(target: "rpc::eth", ?request, ?block_id, "Serving eth_createAccessList");
+        let access_list_with_gas_used = self.create_access_list_at(request, block_id).await?;
 
         Ok(access_list_with_gas_used)
     }
@@ -416,10 +416,10 @@ where
         &self,
         address: Address,
         keys: Vec<JsonStorageKey>,
-        block_number: Option<BlockId>,
+        block_id: Option<BlockId>,
     ) -> Result<EIP1186AccountProofResponse> {
-        trace!(target: "rpc::eth", ?address, ?keys, ?block_number, "Serving eth_getProof");
-        let res = EthApi::get_proof(self, address, keys, block_number).await;
+        trace!(target: "rpc::eth", ?address, ?keys, ?block_id, "Serving eth_getProof");
+        let res = EthApi::get_proof(self, address, keys, block_id).await;
 
         Ok(res.map_err(|e| match e {
             EthApiError::InvalidBlockRange => {

crates/rpc/rpc/src/eth/api/transactions.rs

@@ -23,7 +23,8 @@ use reth_primitives::{
     TransactionMeta, TransactionSigned, TransactionSignedEcRecovered, B256, U128, U256, U64,
 };
 use reth_provider::{
-    BlockReaderIdExt, ChainSpecProvider, EvmEnvProvider, StateProviderBox, StateProviderFactory,
+    BlockReaderIdExt, ChainSpecProvider, EvmEnvProvider, ProviderError, StateProviderBox,
+    StateProviderFactory,
 };
 use reth_revm::{
     database::StateProviderDatabase,
@@ -535,8 +536,11 @@ where
             let block_hash = self
                 .provider()
                 .block_hash_for_id(at)?
-                .ok_or_else(|| EthApiError::UnknownBlockNumber)?;
-            let (cfg, env) = self.cache().get_evm_env(block_hash).await?;
+                .ok_or_else(|| EthApiError::UnknownBlockId(at))?;
+            let (cfg, env) = self.cache().get_evm_env(block_hash).await.map_err(|e| match e {
+                ProviderError::HeaderNotFound(_) => EthApiError::UnknownBlockId(at),
+                _ => e.into(),
+            })?;
             Ok((cfg, env, block_hash.into()))
         }
     }

crates/rpc/rpc/src/eth/error.rs

@@ -9,7 +9,7 @@ use jsonrpsee::{
 use reth_interfaces::RethError;
 use reth_primitives::{revm_primitives::InvalidHeader, Address, Bytes, U256};
 use reth_revm::tracing::{js::JsInspectorError, MuxError};
-use reth_rpc_types::{error::EthRpcErrorCode, request::TransactionInputError, BlockError};
+use reth_rpc_types::{error::EthRpcErrorCode, request::TransactionInputError, BlockError, BlockId};
 use reth_transaction_pool::error::{
     Eip4844PoolTransactionError, InvalidPoolTransactionError, PoolError, PoolErrorKind,
     PoolTransactionError,
@@ -44,6 +44,9 @@ pub enum EthApiError {
     /// When an unknown block number is encountered
     #[error("unknown block number")]
     UnknownBlockNumber,
+    /// When an unknown block is encountered
+    #[error("unknown block id")]
+    UnknownBlockId(BlockId),
     /// Thrown when querying for `finalized` or `safe` block before the merge transition is
     /// finalized, <https://github.com/ethereum/execution-apis/blob/6d17705a875e52c26826124c2a8a15ed542aeca2/src/schemas/block.yaml#L109>
     #[error("unknown block")]
@@ -156,6 +159,22 @@ impl From<EthApiError> for ErrorObject<'static> {
             EthApiError::UnknownBlockNumber | EthApiError::UnknownBlockOrTxIndex => {
                 rpc_error_with_code(EthRpcErrorCode::ResourceNotFound.code(), error.to_string())
             }
+            EthApiError::UnknownBlockId(id) => {
+                let arg = match id {
+                    BlockId::Hash(h) => {
+                        if h.require_canonical == Some(true) {
+                            format!("canonical hash {}", h.block_hash)
+                        } else {
+                            format!("hash {}", h.block_hash)
+                        }
+                    }
+                    BlockId::Number(n) => format!("number {}", n),
+                };
+                rpc_error_with_code(
+                    EthRpcErrorCode::ResourceNotFound.code(),
+                    format!("{}: {}", error, arg),
+                )
+            }
             EthApiError::UnknownSafeOrFinalizedBlock => {
                 rpc_error_with_code(EthRpcErrorCode::UnknownBlock.code(), error.to_string())
             }