pallet-revive-eth-rpc: Introduce SubstrateClientT trait abstraction and Asset Hub embedded RPC integration

Cargo.toml

@@ -1045,6 +1045,7 @@ pallet-ranked-collective = { path = "substrate/frame/ranked-collective", default
 pallet-recovery = { path = "substrate/frame/recovery", default-features = false }
 pallet-referenda = { path = "substrate/frame/referenda", default-features = false }
 pallet-revive = { path = "substrate/frame/revive", default-features = false }
+pallet-revive-eth-rpc = { path = "substrate/frame/revive/rpc", default-features = false }
 pallet-revive-fixtures = { path = "substrate/frame/revive/fixtures", default-features = false }
 pallet-revive-proc-macro = { path = "substrate/frame/revive/proc-macro", default-features = false }
 pallet-revive-uapi = { path = "substrate/frame/revive/uapi", default-features = false }

cumulus/polkadot-omni-node/lib/Cargo.toml

@@ -40,6 +40,8 @@ frame-benchmarking-cli = { workspace = true, default-features = true }
 frame-support = { optional = true, workspace = true, default-features = true }
 frame-system-rpc-runtime-api = { workspace = true, default-features = true }
 frame-try-runtime = { optional = true, workspace = true, default-features = true }
+pallet-revive = { workspace = true, default-features = true }
+pallet-revive-eth-rpc = { workspace = true, default-features = false }
 pallet-transaction-payment = { workspace = true, default-features = true }
 pallet-transaction-payment-rpc = { workspace = true, default-features = true }
 pallet-transaction-payment-rpc-runtime-api = { workspace = true, default-features = true }
@@ -108,6 +110,7 @@ cumulus-primitives-core = { workspace = true, default-features = true }
 cumulus-relay-chain-interface = { workspace = true, default-features = true }
 futures-timer = { workspace = true }
 sc-consensus-aura = { workspace = true }
+tokio = { workspace = true, features = ["rt-multi-thread"] }
 
 [dev-dependencies]
 assert_cmd = { workspace = true }
@@ -125,6 +128,7 @@ runtime-benchmarks = [
 	"frame-benchmarking-cli/runtime-benchmarks",
 	"frame-benchmarking/runtime-benchmarks",
 	"frame-support/runtime-benchmarks",
+	"pallet-revive/runtime-benchmarks",
 	"pallet-transaction-payment/runtime-benchmarks",
 	"polkadot-cli/runtime-benchmarks",
 	"polkadot-primitives/runtime-benchmarks",
@@ -135,6 +139,7 @@ runtime-benchmarks = [
 try-runtime = [
 	"frame-support/try-runtime",
 	"frame-try-runtime/try-runtime",
+	"pallet-revive/try-runtime",
 	"pallet-transaction-payment/try-runtime",
 	"polkadot-cli/try-runtime",
 	"sp-runtime/try-runtime",

cumulus/polkadot-omni-node/lib/src/command.rs

@@ -63,7 +63,7 @@ pub fn new_aura_node_spec<Block>(
 	extra_args: &NodeExtraArgs,
 ) -> Box<dyn DynNodeSpec>
 where
-	Block: NodeBlock,
+	Block: NodeBlock<BoundedNumber = u32>,
 {
 	match aura_id {
 		AuraConsensusId::Sr25519 => crate::nodes::aura::new_aura_node_spec::<
@@ -91,8 +91,12 @@ fn new_node_spec(
 			(BlockNumber::U32, Consensus::Aura(aura_id)) => {
 				new_aura_node_spec::<Block<u32>>(aura_id, extra_args)
 			},
-			(BlockNumber::U64, Consensus::Aura(aura_id)) => {
-				new_aura_node_spec::<Block<u64>>(aura_id, extra_args)
+			(BlockNumber::U64, Consensus::Aura(_)) => {
+				return Err(sc_cli::Error::Application(
+					"u64 block numbers are not supported when the ETH RPC (pallet-revive) \
+					 is enabled; the runtime must use u32 block numbers"
+						.into(),
+				))
 			},
 		},
 	})

cumulus/polkadot-omni-node/lib/src/common/rpc.rs

@@ -35,6 +35,188 @@ use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer
 /// A type representing all RPC extensions.
 pub type RpcExtension = jsonrpsee::RpcModule<()>;
 
+pub(crate) use eth_rpc::BuildParachainRpcExtensions;
+
+mod eth_rpc {
+	use super::*;
+	use pallet_revive_eth_rpc::{
+		cli::{build_eth_rpc_module, build_native_inmemory_client},
+		client::SubscriptionType,
+		native_client::ReviveRuntimeApiT,
+		NativeClientBlockInfoProvider, NativeSubstrateClient,
+	};
+	use sp_api::{Metadata as _, ProvideRuntimeApi};
+	use sp_core::H256;
+
+	/// The default number of recent blocks kept in the in-memory receipt cache.
+	const DEFAULT_KEEP_LATEST_BLOCKS: usize = 256;
+
+	/// Reads the `ChainId` constant from the `Revive` pallet via the runtime metadata.
+	fn read_revive_chain_id<B, C>(
+		client: &Arc<C>,
+		best_hash: B::Hash,
+	) -> Result<u64, Box<dyn std::error::Error + Send + Sync>>
+	where
+		B: BlockT,
+		C: ProvideRuntimeApi<B>,
+		C::Api: sp_api::Metadata<B>,
+	{
+		use codec::Decode as _;
+
+		let opaque = client
+			.runtime_api()
+			.metadata(best_hash)
+			.map_err(|e| format!("metadata API error: {e}"))?;
+
+		let meta = subxt_metadata::Metadata::decode(&mut &opaque[..])
+			.map_err(|e| format!("metadata decode error: {e}"))?;
+
+		let value = meta
+			.pallet_by_name("Revive")
+			.and_then(|p| p.constant_by_name("ChainId"))
+			.map(|c| c.value().to_vec())
+			.ok_or("Revive pallet `ChainId` constant not found in runtime metadata")?;
+
+		u64::decode(&mut &value[..]).map_err(|e| format!("ChainId decode error: {e}").into())
+	}
+
+	pub(crate) struct BuildParachainRpcExtensions<Block, RuntimeApi>(
+		PhantomData<(Block, RuntimeApi)>,
+	);
+
+	impl<Block, RuntimeApi>
+		BuildRpcExtensions<
+			ParachainClient<Block, RuntimeApi>,
+			ParachainBackend<Block>,
+			sc_transaction_pool::TransactionPoolHandle<Block, ParachainClient<Block, RuntimeApi>>,
+			sc_statement_store::Store,
+		> for BuildParachainRpcExtensions<Block, RuntimeApi>
+	where
+		Block: BlockT<Hash = H256, Extrinsic = sp_runtime::OpaqueExtrinsic> + Send + Sync + 'static,
+		Block::Header:
+			sp_runtime::traits::Header<Number = u32, Hash = H256> + Unpin + Send + Sync + 'static,
+		RuntimeApi: ConstructNodeRuntimeApi<Block, ParachainClient<Block, RuntimeApi>>
+			+ Send
+			+ Sync
+			+ 'static,
+		RuntimeApi::RuntimeApi: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
+			+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>
+			+ ReviveRuntimeApiT<Block, u64>,
+	{
+		fn build_rpc_extensions(
+			client: Arc<ParachainClient<Block, RuntimeApi>>,
+			backend: Arc<ParachainBackend<Block>>,
+			pool: Arc<
+				sc_transaction_pool::TransactionPoolHandle<
+					Block,
+					ParachainClient<Block, RuntimeApi>,
+				>,
+			>,
+			statement_store: Option<Arc<sc_statement_store::Store>>,
+			spawn_handle: Arc<dyn sp_core::traits::SpawnNamed>,
+		) -> sc_service::error::Result<RpcExtension> {
+			let build = || -> Result<RpcExtension, Box<dyn std::error::Error + Send + Sync>> {
+				let mut module = RpcExtension::new(());
+
+				// Standard parachain RPCs.
+				module.merge(System::new(client.clone(), pool.clone()).into_rpc())?;
+				module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
+				module.merge(StateMigration::new(client.clone(), backend).into_rpc())?;
+				if let Some(statement_store) = statement_store {
+					module.merge(
+						StatementStore::new(statement_store, spawn_handle.clone()).into_rpc(),
+					)?;
+				}
+				module.merge(Dev::new(client.clone()).into_rpc())?;
+
+				// ETH RPC server.
+				let best_hash = client.chain_info().best_hash;
+				match read_revive_chain_id::<Block, _>(&client, best_hash) {
+					Ok(chain_id) => {
+						let block_provider = NativeClientBlockInfoProvider::new(client.clone())
+							.map_err(|e| format!("block info provider: {e}"))?;
+
+						let native_client =
+							NativeSubstrateClient::new(client.clone(), pool, chain_id, false)
+								.map_err(|e| format!("native substrate client: {e}"))?;
+
+						let (bootstrap_tx, bootstrap_rx) = std::sync::mpsc::sync_channel(1);
+						spawn_handle.spawn(
+							"eth-rpc-bootstrap",
+							Some("eth-rpc"),
+							Box::pin(async move {
+								let result = build_native_inmemory_client(
+									native_client,
+									block_provider,
+									DEFAULT_KEEP_LATEST_BLOCKS,
+									false,
+								)
+								.await
+								.map_err(|e| format!("ETH RPC client init: {e}"));
+								let _ = bootstrap_tx.send(result);
+							}),
+						);
+						let eth_client = bootstrap_rx
+							.recv()
+							.map_err(|_| "eth-rpc bootstrap task did not return".to_string())??;
+
+						let eth_best = eth_client.clone();
+						spawn_handle.spawn(
+							"eth-rpc-best-blocks",
+							Some("eth-rpc"),
+							Box::pin(async move {
+								if let Err(e) = eth_best
+									.subscribe_and_cache_new_blocks(SubscriptionType::BestBlocks)
+									.await
+								{
+									log::error!(
+										target: "eth-rpc",
+										"Best-block subscription error: {e:?}"
+									);
+								}
+							}),
+						);
+						let eth_finalized = eth_client.clone();
+						spawn_handle.spawn(
+							"eth-rpc-finalized-blocks",
+							Some("eth-rpc"),
+							Box::pin(async move {
+								if let Err(e) = eth_finalized
+									.subscribe_and_cache_new_blocks(
+										SubscriptionType::FinalizedBlocks,
+									)
+									.await
+								{
+									log::error!(
+										target: "eth-rpc",
+										"Finalized-block subscription error: {e:?}"
+									);
+								}
+							}),
+						);
+
+						// `include_system_health = false` because the parachain node already
+						// merges `sc_rpc::system::System` (which exposes `system_health`)
+						// in `sc_service::gen_rpc_module` — adding the eth-rpc one here
+						// would fail with a duplicate-method error and tear down the node.
+						let eth_module = build_eth_rpc_module(false, eth_client, false, false)?;
+						module.merge(eth_module)?;
+					},
+					Err(e) => {
+						log::debug!(
+							target: "eth-rpc",
+							"Revive pallet not found in runtime metadata, ETH RPC disabled: {e}"
+						);
+					},
+				}
+
+				Ok(module)
+			};
+			build().map_err(Into::into)
+		}
+	}
+}
+
 pub(crate) trait BuildRpcExtensions<Client, Backend, Pool, StatementStore> {
 	fn build_rpc_extensions(
 		client: Arc<Client>,
@@ -44,44 +226,3 @@ pub(crate) trait BuildRpcExtensions<Client, Backend, Pool, StatementStore> {
 		spawn_handle: Arc<dyn sp_core::traits::SpawnNamed>,
 	) -> sc_service::error::Result<RpcExtension>;
 }
-
-pub(crate) struct BuildParachainRpcExtensions<Block, RuntimeApi>(PhantomData<(Block, RuntimeApi)>);
-
-impl<Block: BlockT, RuntimeApi>
-	BuildRpcExtensions<
-		ParachainClient<Block, RuntimeApi>,
-		ParachainBackend<Block>,
-		sc_transaction_pool::TransactionPoolHandle<Block, ParachainClient<Block, RuntimeApi>>,
-		sc_statement_store::Store,
-	> for BuildParachainRpcExtensions<Block, RuntimeApi>
-where
-	RuntimeApi:
-		ConstructNodeRuntimeApi<Block, ParachainClient<Block, RuntimeApi>> + Send + Sync + 'static,
-	RuntimeApi::RuntimeApi: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
-		+ substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>,
-{
-	fn build_rpc_extensions(
-		client: Arc<ParachainClient<Block, RuntimeApi>>,
-		backend: Arc<ParachainBackend<Block>>,
-		pool: Arc<
-			sc_transaction_pool::TransactionPoolHandle<Block, ParachainClient<Block, RuntimeApi>>,
-		>,
-		statement_store: Option<Arc<sc_statement_store::Store>>,
-		spawn_handle: Arc<dyn sp_core::traits::SpawnNamed>,
-	) -> sc_service::error::Result<RpcExtension> {
-		let build = || -> Result<RpcExtension, Box<dyn std::error::Error + Send + Sync>> {
-			let mut module = RpcExtension::new(());
-
-			module.merge(System::new(client.clone(), pool).into_rpc())?;
-			module.merge(TransactionPayment::new(client.clone()).into_rpc())?;
-			module.merge(StateMigration::new(client.clone(), backend).into_rpc())?;
-			if let Some(statement_store) = statement_store {
-				module.merge(StatementStore::new(statement_store, spawn_handle).into_rpc())?;
-			}
-			module.merge(Dev::new(client).into_rpc())?;
-
-			Ok(module)
-		};
-		build().map_err(Into::into)
-	}
-}