chore(rpc): re-optimize endpoints (#6)

* chore(rpc): re-optimize endpoints

Seems this was not included when migrating out of the SDK.

* chore(repo): clippy / fmt

With the new edition/version bump there's a bunch of clippy / fmt changes to do.

Author: Evalir

Cargo.toml

@@ -3,9 +3,9 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.8.4"
-edition = "2021"
-rust-version = "1.82"
+version = "0.8.2"
+edition = "2024"
+rust-version = "1.88"
 authors = ["init4"]
 license = "MIT OR Apache-2.0"
 homepage = "https://github.com/init4tech/signet-sdk"

crates/blobber/src/block_data.rs

@@ -1,11 +1,11 @@
 use crate::{
-    error::UnrecoverableBlobError, shim::ExtractableChainShim, BlockExtractionError,
-    BlockExtractorBuilder, ExtractionResult,
+    BlockExtractionError, BlockExtractorBuilder, ExtractionResult, error::UnrecoverableBlobError,
+    shim::ExtractableChainShim,
 };
 use alloy::{
     consensus::{Blob, SidecarCoder, SimpleCoder},
     eips::eip7594::BlobTransactionSidecarVariant,
-    primitives::{keccak256, TxHash, B256},
+    primitives::{B256, TxHash, keccak256},
 };
 use init4_bin_base::utils::calc::SlotCalculator;
 use reth::{
@@ -334,15 +334,15 @@ mod tests {
             BlobTransactionSidecar, SidecarBuilder, SignableTransaction, TxEip2930, TxEnvelope,
         },
         eips::Encodable2718,
-        primitives::{bytes, Address, TxKind, U256},
+        primitives::{Address, TxKind, U256, bytes},
         rlp::encode,
-        signers::{local::PrivateKeySigner, SignerSync},
+        signers::{SignerSync, local::PrivateKeySigner},
     };
     use foundry_blob_explorers::TransactionDetails;
     use reth::primitives::{Transaction, TransactionSigned};
     use reth_transaction_pool::{
-        test_utils::{testing_pool, MockTransaction},
         PoolTransaction, TransactionOrigin,
+        test_utils::{MockTransaction, testing_pool},
     };
     use signet_types::constants::SignetSystemConstants;
 

crates/blobber/src/builder.rs

@@ -1,4 +1,4 @@
-use crate::{block_data::BlockExtractor, BlockExtractorConfig};
+use crate::{BlockExtractorConfig, block_data::BlockExtractor};
 use init4_bin_base::utils::calc::SlotCalculator;
 use reth::transaction_pool::TransactionPool;
 use url::Url;

crates/db/src/provider.rs

@@ -1,11 +1,11 @@
 use crate::{
+    DataCompat, DbZenithHeader, RuChain, ZenithHeaders,
     tables::{DbSignetEvent, JournalHashes, SignetEvents},
     traits::RuWriter,
-    DataCompat, DbZenithHeader, RuChain, ZenithHeaders,
 };
 use alloy::{
     consensus::{BlockHeader, TxReceipt},
-    primitives::{map::HashSet, Address, BlockNumber, B256, U256},
+    primitives::{Address, B256, BlockNumber, U256, map::HashSet},
 };
 use reth::{
     primitives::{Account, StaticFileSegment},
@@ -17,13 +17,13 @@ use reth::{
     },
 };
 use reth_db::{
+    PlainAccountState,
     cursor::{DbCursorRO, DbCursorRW},
     models::{BlockNumberAddress, StoredBlockBodyIndices},
     tables,
     transaction::{DbTx, DbTxMut},
-    PlainAccountState,
 };
-use reth_prune_types::{PruneMode, MINIMUM_PRUNING_DISTANCE};
+use reth_prune_types::{MINIMUM_PRUNING_DISTANCE, PruneMode};
 use signet_evm::BlockResult;
 use signet_node_types::{NodeTypesDbTrait, SignetNodeTypes};
 use signet_types::primitives::RecoveredBlock;

crates/db/src/tables.rs

@@ -1,10 +1,11 @@
 use alloy::{
-    primitives::{bytes::BufMut, Address, BlockNumber, Bytes, B256, U256},
+    primitives::{Address, B256, BlockNumber, Bytes, U256, bytes::BufMut},
     rlp::Buf,
 };
 use reth_db::{
+    DatabaseError,
     table::{Compress, Decompress, DupSort, Table},
-    tables, DatabaseError,
+    tables,
 };
 use signet_zenith::{
     Passage::{Enter, EnterToken},

crates/db/src/traits.rs

@@ -1,5 +1,5 @@
 use crate::{DbExtractionResults, DbSignetEvent, RuChain};
-use alloy::primitives::{Address, BlockNumber, B256, U256};
+use alloy::primitives::{Address, B256, BlockNumber, U256};
 use itertools::Itertools;
 use reth::{
     primitives::Account,

crates/rpc/examples/filler.rs

@@ -3,16 +3,16 @@ use alloy::{
     network::{Ethereum, EthereumWallet, TransactionBuilder},
     primitives::Bytes,
     providers::{
+        Identity, Provider as _, RootProvider, SendableTx,
         fillers::{
             BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,
             WalletFiller,
         },
-        Identity, Provider as _, RootProvider, SendableTx,
     },
-    rpc::types::{mev::EthSendBundle, TransactionRequest},
+    rpc::types::{TransactionRequest, mev::EthSendBundle},
     signers::Signer,
 };
-use eyre::{eyre, Error};
+use eyre::{Error, eyre};
 use signet_bundle::SignetEthBundle;
 use signet_constants::SignetConstants;
 use signet_tx_cache::{client::TxCache, types::TxCacheSendBundleResponse};

crates/rpc/examples/order.rs

@@ -1,11 +1,11 @@
 use alloy::{
     consensus::constants::GWEI_TO_WEI,
-    primitives::{uint, U256},
+    primitives::{U256, uint},
     signers::Signer,
 };
 use chrono::Utc;
 use eyre::Error;
-use signet_constants::{SignetConstants, NATIVE_TOKEN_ADDRESS};
+use signet_constants::{NATIVE_TOKEN_ADDRESS, SignetConstants};
 use signet_tx_cache::client::TxCache;
 use signet_types::UnsignedOrder;
 use signet_zenith::RollupOrders::{Input, Order, Output};

crates/rpc/src/config.rs

@@ -1,4 +1,4 @@
-use ajj::{pubsub::ServerShutdown, Router};
+use ajj::{Router, pubsub::ServerShutdown};
 use reth::{args::RpcServerArgs, tasks::TaskExecutor};
 use std::net::SocketAddr;
 use tokio::task::JoinHandle;

crates/rpc/src/ctx.rs

@@ -1,9 +1,9 @@
 use crate::{
+    Pnt,
     eth::EthError,
     interest::{ActiveFilter, FilterManager, FilterOutput, SubscriptionManager},
     receipts::build_signet_receipt,
     util::BlockRangeInclusiveIter,
-    Pnt,
 };
 use alloy::{
     consensus::{BlockHeader, Header, Signed, Transaction, TxEnvelope},
@@ -16,21 +16,21 @@ use reth::{
     core::primitives::SignerRecoverable,
     primitives::{Block, EthPrimitives, Receipt, Recovered, RecoveredBlock, TransactionSigned},
     providers::{
-        providers::{BlockchainProvider, ProviderNodeTypes},
         BlockHashReader, BlockIdReader, BlockNumReader, CanonStateSubscriptions, HeaderProvider,
         ProviderBlock, ProviderError, ProviderReceipt, ReceiptProvider, StateProviderFactory,
         TransactionsProvider,
+        providers::{BlockchainProvider, ProviderNodeTypes},
     },
     revm::{database::StateProviderDatabase, primitives::hardfork::SpecId},
     rpc::{
         eth::{filter::EthFilterError, helpers::types::EthRpcConverter},
         server_types::eth::{
+            EthApiError, EthConfig, EthStateCache, FeeHistoryCache, FeeHistoryEntry,
+            GasPriceOracle,
             fee_history::{
                 calculate_reward_percentiles_for_block, fee_history_cache_new_blocks_task,
             },
-            logs_utils::{self, append_matching_block_logs, ProviderOrBlock},
-            EthApiError, EthConfig, EthStateCache, FeeHistoryCache, FeeHistoryEntry,
-            GasPriceOracle,
+            logs_utils::{self, ProviderOrBlock, append_matching_block_logs},
         },
         types::{FilterBlockOption, FilteredParams},
     },
@@ -41,12 +41,12 @@ use reth_node_api::{BlockBody, FullNodeComponents};
 use reth_rpc_eth_api::{RpcBlock, RpcConvert, RpcReceipt, RpcTransaction};
 use signet_evm::EvmNeedsTx;
 use signet_tx_cache::client::TxCache;
-use signet_types::{constants::SignetSystemConstants, MagicSig};
+use signet_types::{MagicSig, constants::SignetSystemConstants};
 use std::{marker::PhantomData, sync::Arc};
-use tracing::{instrument, trace, Level};
+use tracing::{Level, instrument, trace};
 use trevm::{
-    revm::{context::CfgEnv, database::StateBuilder},
     Cfg,
+    revm::{context::CfgEnv, database::StateBuilder},
 };
 
 /// Type alias for EVMs using a [`StateProviderBox`] as the `DB` type for
@@ -312,6 +312,20 @@ where
         Ok(builder.build())
     }
 
+    /// Get the [`Header`] for a given block.
+    pub async fn raw_header(
+        &self,
+        t: impl Into<BlockId>,
+    ) -> Result<Option<(B256, Header)>, EthApiError> {
+        let Some(hash) = self.provider.block_hash_for_id(t.into())? else {
+            return Ok(None);
+        };
+
+        let header = self.cache.get_header(hash).await.map_err(EthApiError::from)?;
+
+        Ok(Some((hash, header)))
+    }
+
     /// Get the block for a given block, returning the block hash and
     /// the block itself.
     pub async fn raw_block(
@@ -513,20 +527,18 @@ where
         build_signet_receipt(tx, meta, receipt, all_receipts.to_vec()).map(Some)
     }
 
-    /// Create the [`Block`] object for a specific [`BlockId`].
+    /// Create the [`Header`] object for a specific [`BlockId`].
     pub async fn block_cfg(&self, mut block_id: BlockId) -> Result<Header, EthApiError> {
         // If the block is pending, we'll load the latest and
         let pending = block_id.is_pending();
         if pending {
             block_id = BlockId::latest();
         }
 
-        let Some((_, block)) = self.raw_block(block_id).await? else {
+        let Some((_, mut header)) = self.raw_header(block_id).await? else {
             return Err(EthApiError::HeaderNotFound(block_id));
         };
 
-        let mut header = block.clone_header();
-
         // Modify the header for pending blocks, to simulate the next block.
         if pending {
             header.parent_hash = header.hash_slow();