POC: simplify SDK

[emhane]

Ref #13951

BlockReader is trait aggregating a lot of stateful behaviour, however it's used as trait bound in type definitions just in order to access the associated data primitive types. A more intentional way to do this, is to make use of the stateless base trait NodePrimitives in the type definition.

reth/crates/rpc/rpc/src/eth/core.rs

Lines 249 to 288 in 6ae48f8

	/// Container type `EthApi`
	#[expect(missing_debug_implementations)]
	pub struct EthApiInner<Provider: BlockReader, Pool, Network, EvmConfig> {
	/// The transaction pool.
	pool: Pool,
	/// The provider that can interact with the chain.
	provider: Provider,
	/// An interface to interact with the network
	network: Network,
	/// All configured Signers
	signers: parking_lot::RwLock<Vec<Box<dyn EthSigner<Provider::Transaction>>>>,
	/// The async cache frontend for eth related data
	eth_cache: EthStateCache<Provider::Block, Provider::Receipt>,
	/// The async gas oracle frontend for gas price suggestions
	gas_oracle: GasPriceOracle<Provider>,
	/// Maximum gas limit for `eth_call` and call tracing RPC methods.
	gas_cap: u64,
	/// Maximum number of blocks for `eth_simulateV1`.
	max_simulate_blocks: u64,
	/// The maximum number of blocks into the past for generating state proofs.
	eth_proof_window: u64,
	/// The block number at which the node started
	starting_block: U256,
	/// The type that can spawn tasks which would otherwise block.
	task_spawner: Box<dyn TaskSpawner>,
	/// Cached pending block if any
	pending_block: Mutex<Option<PendingBlock<Provider::Block, Provider::Receipt>>>,
	/// A pool dedicated to CPU heavy blocking tasks.
	blocking_task_pool: BlockingTaskPool,
	/// Cache for block fees history
	fee_history_cache: FeeHistoryCache,
	/// The type that defines how to configure the EVM
	evm_config: EvmConfig,
	/// Guard for getproof calls
	blocking_task_guard: BlockingTaskGuard,
	/// Transaction broadcast channel
	raw_tx_sender: broadcast::Sender<Bytes>,
	}

Since NodePrimitives is stateless, it can effortlessly become supertrait of any provider trait and removes the need for adding the same associated types again explicitly to the provider traits.

All provider traits read to and from the same database so there is no need to separately configure and therefore to define new associated types TransactionProvider::Transaction, HeaderProvider::Header, etc. creating overhead as we need to link them to the rest of the node, e.g. TransactionProvider::Transaction == <N as NodePrimitives>::SignedTx. It also saves the need for the trait NodePrimitivesProvider, hereby removing an extra complexity layer.

reth/crates/storage/storage-api/src/header.rs

Lines 11 to 15 in 6ae48f8

	/// Client trait for fetching `Header` related data.
	#[auto_impl::auto_impl(&, Arc)]
	pub trait HeaderProvider: Send + Sync {
	/// The header type this provider supports.
	type Header: BlockHeader;

Alt approaches: creating a new trait NodePrimitivesBase, identical associated types as NodePrimitives but without trait bounds on the associated types and using this as super trait instead and in type defs, similar as RpcNodeCore. This approach was out-ruled because it adds more code, whereas the PR aims to remove redundancy and create stronger cohesion in the SDK abstraction to its origin in NodePrimitives.

[emhane]

places that require trait bounds like these can be collapsed into some helper trait eventually HalfFullNodePrimitives or smthg. NodePrimitives can't be static for example in order to be supertrait of traits of T that should be implemented on &T also. @mattsse

[emhane]

alt, we can upgrade the trait bound everywhere where it needs to be static/Clone/etc. to FullNodePrimitives. it works quite nicely with the MaybeCompact and other Maybe- traits in reth-primitives-traits to just include the trait bound everywhere, even where Compact isn't needed, without any overhead.