Create a ChainSpec Wrapper to manage Anvil genesis config

crates/anvil-polkadot/Cargo.toml

@@ -19,6 +19,7 @@ path = "bin/main.rs"
 
 [dependencies]
 # foundry internal
+codec = { version = "3.7.5", default-features = true, package = "parity-scale-codec" }
 substrate-runtime = { path = "substrate-runtime" }
 polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch = "master", default-features = false, features = [
     "sc-allocator",
@@ -34,13 +35,16 @@ polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk.git", branch
 	"sc-executor-common",
 	"sc-executor-wasmtime",
 	"sc-keystore",
+	"sc-network",
 	"sc-network-types",
     "sc-rpc",
 	"sc-rpc-api",
 	"sc-rpc-server",
 	"sc-rpc-spec-v2",
+	"sc-runtime-utilities",
 	"sc-service",
 	"sc-state-db",
+	"sc-telemetry",
 	"sc-tracing",
 	"sc-transaction-pool",
 	"sc-transaction-pool-api",
@@ -128,10 +132,10 @@ clap = { version = "4", features = [
 clap_complete = { version = "4" }
 chrono.workspace = true
 clap_complete_fig = "4"
-parity-scale-codec = "3.7.5"
 subxt = "0.43.0"
 subxt-signer = "0.43.0"
 tokio-stream = "0.1.17"
+jsonrpsee = "0.24.9"
 sqlx = "0.8.6"
 
 [dev-dependencies]

crates/anvil-polkadot/src/api_server/server.rs

@@ -18,6 +18,7 @@ use alloy_rpc_types::{TransactionRequest, anvil::MineOptions};
 use alloy_serde::WithOtherFields;
 use anvil_core::eth::{EthRequest, Params as MineParams};
 use anvil_rpc::response::ResponseResult;
+use codec::Decode;
 use futures::{StreamExt, channel::mpsc};
 use polkadot_sdk::{
     pallet_revive::evm::{Account, Block, Bytes, ReceiptInfo},
@@ -26,12 +27,19 @@ use polkadot_sdk::{
         client::{Client as EthRpcClient, ClientError, SubscriptionType},
         subxt_client::{self, SrcChainConfig},
     },
-    sp_core::{self, keccak_256},
+    sc_client_api::StorageProvider,
+    sc_executor::WasmExecutor,
+    sc_runtime_utilities::fetch_latest_metadata_from_code_blob,
+    sp_core::{self, keccak_256, storage::StorageKey},
+    sp_io::SubstrateHostFunctions,
+    sp_runtime::Cow,
+    sp_storage::well_known_keys::CODE as CODE_KEY,
 };
 use sqlx::sqlite::SqlitePoolOptions;
 use std::{sync::Arc, time::Duration};
 use subxt::{
-    OnlineClient, backend::rpc::RpcClient, config::substrate::H256,
+    Metadata as SubxtMetadata, OnlineClient, backend::rpc::RpcClient,
+    client::RuntimeVersion as SubxtRuntimeVersion, config::substrate::H256,
     ext::subxt_rpcs::LegacyRpcMethods, utils::H160,
 };
 
@@ -411,7 +419,40 @@ impl ApiServer {
 
 async fn create_revive_rpc_client(substrate_service: &Service) -> Result<EthRpcClient> {
     let rpc_client = RpcClient::new(InMemoryRpcClient(substrate_service.rpc_handlers.clone()));
-    let api = OnlineClient::<SrcChainConfig>::from_rpc_client(rpc_client.clone()).await?;
+
+    // Using best_hash because genesis hash is only set if genesis block number is equal to 0, but
+    // Anvil allows a custom genesis block number.
+    // https://github.com/paritytech/polkadot-sdk/blob/62c3a80f913a272c4f5dba2c91320056d39ec68e/substrate/client/api/src/in_mem.rs#L178
+    let genesis_hash = substrate_service.client.chain_info().best_hash;
+
+    let runtime_version = substrate_service
+        .client
+        .runtime_version_at(genesis_hash)
+        .expect("Runtime version not found for given genesis hash");
+    let subxt_runtime_version = SubxtRuntimeVersion {
+        spec_version: runtime_version.spec_version,
+        transaction_version: runtime_version.transaction_version,
+    };
+
+    let code_bytes = substrate_service
+        .client
+        .storage(genesis_hash, &StorageKey(CODE_KEY.to_vec()))
+        .expect("Runtime code not found for given genesis hash")
+        .unwrap();
+    let opaque_metadata = fetch_latest_metadata_from_code_blob(
+        &WasmExecutor::<SubstrateHostFunctions>::builder().build(),
+        Cow::Borrowed(code_bytes.0.as_slice()),
+    )
+    .map_err(|_| Error::InvalidParams("Unable to fetch metadata".to_string()))?;
+    let subxt_metadata = SubxtMetadata::decode(&mut (*opaque_metadata).as_slice())
+        .map_err(|_| Error::InvalidParams("Unable to decode metadata".to_string()))?;
+
+    let api = OnlineClient::<SrcChainConfig>::from_rpc_client_with(
+        genesis_hash,
+        subxt_runtime_version,
+        subxt_metadata,
+        rpc_client.clone(),
+    )?;
     let rpc = LegacyRpcMethods::<SrcChainConfig>::new(rpc_client.clone());
 
     let block_provider = SubxtBlockInfoProvider::new(api.clone(), rpc.clone()).await?;

crates/anvil-polkadot/src/lib.rs

@@ -6,7 +6,7 @@ use crate::{
     api_server::ApiHandle,
     config::AnvilNodeConfig,
     logging::{LoggingManager, NodeLogLayer},
-    substrate_node::service::Service,
+    substrate_node::{genesis::GenesisConfig, service::Service},
 };
 use clap::{CommandFactory, Parser};
 use eyre::Result;
@@ -83,10 +83,12 @@ pub fn run_command(args: Anvil) -> Result<()> {
         }
         return Ok(());
     }
-    let substrate_client = opts::SubstrateCli {};
 
     let (anvil_config, substrate_config) = args.node.into_node_config()?;
 
+    let substrate_client =
+        opts::SubstrateCli { genesis_config: GenesisConfig::from(&anvil_config) };
+
     let tokio_runtime = build_runtime()?;
 
     let signals = tokio_runtime.block_on(async { sc_cli::Signals::capture() })?;

crates/anvil-polkadot/src/opts.rs

@@ -1,4 +1,7 @@
-use crate::{cmd::NodeArgs, substrate_node::chain_spec};
+use crate::{
+    cmd::NodeArgs,
+    substrate_node::{chain_spec, genesis::GenesisConfig},
+};
 use clap::{Parser, Subcommand};
 use foundry_cli::opts::GlobalArgs;
 use foundry_common::version::{LONG_VERSION, SHORT_VERSION};
@@ -31,7 +34,10 @@ pub enum AnvilSubcommand {
     GenerateFigSpec,
 }
 
-pub struct SubstrateCli;
+pub struct SubstrateCli {
+    // Used to inject the anvil config into the chain spec
+    pub genesis_config: GenesisConfig,
+}
 
 // Implementation of the SubstrateCli, which enables us to launch an in-process substrate node.
 impl sc_cli::SubstrateCli for SubstrateCli {
@@ -63,12 +69,7 @@ impl sc_cli::SubstrateCli for SubstrateCli {
         "anvil-polkadot".into()
     }
 
-    fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
-        Ok(match id {
-            "dev" | "" => Box::new(chain_spec::development_chain_spec()?),
-            path => {
-                Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?)
-            }
-        })
+    fn load_spec(&self, _: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+        Ok(Box::new(chain_spec::development_chain_spec(self.genesis_config.clone())?))
     }
 }

crates/anvil-polkadot/src/substrate_node/chain_spec.rs

@@ -1,11 +1,105 @@
+use crate::substrate_node::genesis::GenesisConfig;
 use polkadot_sdk::{
-    sc_service::{self, ChainType, Properties},
+    sc_chain_spec::{ChainSpec, GetExtension},
+    sc_executor::HostFunctions,
+    sc_network::config::MultiaddrWithPeerId,
+    sc_service::{ChainType, GenericChainSpec, Properties},
+    sc_telemetry::TelemetryEndpoints,
+    sp_core::storage::Storage,
     sp_genesis_builder,
+    sp_runtime::BuildStorage,
 };
 use substrate_runtime::WASM_BINARY;
 
-/// This is a specialization of the general Substrate ChainSpec type.
-pub type ChainSpec = sc_service::GenericChainSpec;
+/// This is a wrapper around the general Substrate ChainSpec type that allows manual changes to the
+/// genesis block.
+#[derive(Clone)]
+pub struct DevelopmentChainSpec<E = Option<()>, EHF = ()> {
+    inner: GenericChainSpec<E, EHF>,
+    genesis_config: GenesisConfig,
+}
+
+impl<E, EHF> BuildStorage for DevelopmentChainSpec<E, EHF>
+where
+    EHF: HostFunctions,
+    GenericChainSpec<E, EHF>: BuildStorage,
+{
+    fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
+        self.inner.assimilate_storage(storage)?;
+        storage.top.extend(self.genesis_config.as_storage_key_value());
+        Ok(())
+    }
+}
+
+impl<E, EHF> ChainSpec for DevelopmentChainSpec<E, EHF>
+where
+    E: GetExtension + serde::Serialize + Clone + Send + Sync + 'static,
+    EHF: HostFunctions,
+{
+    fn boot_nodes(&self) -> &[MultiaddrWithPeerId] {
+        self.inner.boot_nodes()
+    }
+
+    fn name(&self) -> &str {
+        self.inner.name()
+    }
+
+    fn id(&self) -> &str {
+        self.inner.id()
+    }
+
+    fn chain_type(&self) -> ChainType {
+        self.inner.chain_type()
+    }
+
+    fn telemetry_endpoints(&self) -> &Option<TelemetryEndpoints> {
+        self.inner.telemetry_endpoints()
+    }
+
+    fn protocol_id(&self) -> Option<&str> {
+        self.inner.protocol_id()
+    }
+
+    fn fork_id(&self) -> Option<&str> {
+        self.inner.fork_id()
+    }
+
+    fn properties(&self) -> Properties {
+        self.inner.properties()
+    }
+
+    fn add_boot_node(&mut self, addr: MultiaddrWithPeerId) {
+        self.inner.add_boot_node(addr)
+    }
+
+    fn extensions(&self) -> &dyn GetExtension {
+        self.inner.extensions() as &dyn GetExtension
+    }
+
+    fn extensions_mut(&mut self) -> &mut dyn GetExtension {
+        self.inner.extensions_mut() as &mut dyn GetExtension
+    }
+
+    fn as_json(&self, raw: bool) -> Result<String, String> {
+        self.inner.as_json(raw)
+    }
+
+    fn as_storage_builder(&self) -> &dyn BuildStorage {
+        self
+    }
+
+    fn cloned_box(&self) -> Box<dyn ChainSpec> {
+        Box::new(Self { inner: self.inner.clone(), genesis_config: self.genesis_config.clone() })
+    }
+
+    fn set_storage(&mut self, storage: Storage) {
+        self.inner.set_storage(storage);
+    }
+
+    fn code_substitutes(&self) -> std::collections::BTreeMap<String, Vec<u8>> {
+        self.inner.code_substitutes()
+    }
+}
 
 fn props() -> Properties {
     let mut properties = Properties::new();
@@ -14,12 +108,18 @@ fn props() -> Properties {
     properties
 }
 
-pub fn development_chain_spec() -> Result<ChainSpec, String> {
-    Ok(ChainSpec::builder(WASM_BINARY.expect("Development wasm not available"), Default::default())
-        .with_name("Development")
-        .with_id("dev")
-        .with_chain_type(ChainType::Development)
-        .with_genesis_config_preset_name(sp_genesis_builder::DEV_RUNTIME_PRESET)
-        .with_properties(props())
-        .build())
+pub fn development_chain_spec(
+    genesis_config: GenesisConfig,
+) -> Result<DevelopmentChainSpec, String> {
+    let inner = GenericChainSpec::builder(
+        WASM_BINARY.expect("Development wasm not available"),
+        Default::default(),
+    )
+    .with_name("Development")
+    .with_id("dev")
+    .with_chain_type(ChainType::Development)
+    .with_genesis_config_preset_name(sp_genesis_builder::DEV_RUNTIME_PRESET)
+    .with_properties(props())
+    .build();
+    Ok(DevelopmentChainSpec { inner, genesis_config })
 }