fix genesis customisation (#391)

* fix timestamp and block number genesis customisation

Author: alindima

Cargo.lock

@@ -612,28 +612,37 @@ impl ApiServer {
     async fn estimate_gas(
         &self,
         request: WithOtherFields<TransactionRequest>,
-        block: Option<alloy_rpc_types::BlockId>,
+        block: Option<BlockId>,
     ) -> Result<sp_core::U256> {
         node_info!("eth_estimateGas");
 
         let hash = self.get_block_hash_for_tag(block).await?;
         let runtime_api = self.eth_rpc_client.runtime_api(hash);
-        let dry_run =
-            runtime_api.dry_run(convert_to_generic_transaction(request.into_inner())).await?;
+        let dry_run = runtime_api
+            .dry_run(
+                convert_to_generic_transaction(request.into_inner()),
+                ReviveBlockId::from(block).inner(),
+            )
+            .await?;
         Ok(dry_run.eth_gas)
     }
 
     async fn call(
         &self,
         request: WithOtherFields<TransactionRequest>,
-        block: Option<alloy_rpc_types::BlockId>,
+        block: Option<BlockId>,
     ) -> Result<Bytes> {
         node_info!("eth_call");
 
         let hash = self.get_block_hash_for_tag(block).await?;
+
         let runtime_api = self.eth_rpc_client.runtime_api(hash);
-        let dry_run =
-            runtime_api.dry_run(convert_to_generic_transaction(request.into_inner())).await?;
+        let dry_run = runtime_api
+            .dry_run(
+                convert_to_generic_transaction(request.into_inner()),
+                ReviveBlockId::from(block).inner(),
+            )
+            .await?;
 
         Ok(dry_run.data.into())
     }

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

@@ -1,7 +1,4 @@
-use crate::{
-    api_server::revive_conversions::ReviveAddress,
-    substrate_node::chain_spec::keypairs_from_private_keys,
-};
+use crate::api_server::revive_conversions::ReviveAddress;
 use alloy_genesis::Genesis;
 use alloy_primitives::{Address, U256, hex, map::HashMap, utils::Unit};
 use alloy_signer::Signer;
@@ -926,3 +923,15 @@ impl AccountGenerator {
         Ok(wallets)
     }
 }
+
+fn keypairs_from_private_keys(
+    accounts: &[PrivateKeySigner],
+) -> Result<Vec<Keypair>, subxt_signer::eth::Error> {
+    accounts
+        .iter()
+        .map(|signer| {
+            let key = Keypair::from_secret_key(signer.credential().to_bytes().into())?;
+            Ok(key)
+        })
+        .collect()
+}

crates/anvil-polkadot/src/config.rs

@@ -1,16 +1,35 @@
 use crate::substrate_node::genesis::GenesisConfig;
-use alloy_signer_local::PrivateKeySigner;
+use codec::{Decode, Encode};
 use polkadot_sdk::{
-    sc_chain_spec::{ChainSpec, GetExtension},
+    sc_chain_spec::{ChainSpec, GetExtension, json_patch},
+    sc_executor,
     sc_executor::HostFunctions,
     sc_network::config::MultiaddrWithPeerId,
     sc_service::{ChainType, GenericChainSpec, Properties},
     sc_telemetry::TelemetryEndpoints,
-    sp_core::storage::Storage,
+    sp_core::{
+        storage::Storage,
+        traits::{CallContext, CodeExecutor, Externalities, FetchRuntimeCode, RuntimeCode},
+    },
+    sp_genesis_builder::Result as BuildResult,
+    sp_io::{self, hashing::blake2_256},
     sp_runtime::BuildStorage,
+    sp_state_machine::BasicExternalities,
 };
-use substrate_runtime::WASM_BINARY;
-use subxt_signer::eth::Keypair;
+use serde_json::Value;
+use std::borrow::Cow;
+
+pub fn development_chain_spec(
+    genesis_config: GenesisConfig,
+) -> Result<DevelopmentChainSpec, String> {
+    let inner = GenericChainSpec::builder(&genesis_config.code, Default::default())
+        .with_name("Development")
+        .with_id("dev")
+        .with_chain_type(ChainType::Development)
+        .with_properties(props())
+        .build();
+    Ok(DevelopmentChainSpec { inner, genesis_config })
+}
 
 /// This is a wrapper around the general Substrate ChainSpec type that allows manual changes to the
 /// genesis block.
@@ -26,8 +45,20 @@ where
     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());
+
+        // We need to initialise the storage used when calling into the runtime for the genesis
+        // config, so that the customised items (like block number and timestamp) will be
+        // seen even in the code that processes the genesis config patch.
+        let temp_storage = storage.clone();
+
+        GenesisBuilderRuntimeCaller::<EHF>::new(&self.genesis_config.code[..])
+            .get_storage_for_patch(
+                self.genesis_config.runtime_genesis_config_patch(),
+                temp_storage,
+            )?
+            .assimilate_storage(storage)?;
+
         Ok(())
     }
 }
@@ -105,35 +136,108 @@ where
 fn props() -> Properties {
     let mut properties = Properties::new();
     properties.insert("tokenDecimals".to_string(), 12.into());
-    properties.insert("tokenSymbol".to_string(), "MINI".into());
+    properties.insert("tokenSymbol".to_string(), "DOT".into());
     properties
 }
 
-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_patch(genesis_config.runtime_genesis_config_patch())
-    .with_properties(props())
-    .build();
-    Ok(DevelopmentChainSpec { inner, genesis_config })
+// This mostly copies the upstream `GenesisConfigBuilderRuntimeCaller`, but with the ability of
+// injecting genesis state even before the genesis config builders in the runtime are run via
+// `GenesisBuilder_build_state`
+struct GenesisBuilderRuntimeCaller<'a, EHF = ()>
+where
+    EHF: HostFunctions,
+{
+    code: Cow<'a, [u8]>,
+    code_hash: Vec<u8>,
+    executor: sc_executor::WasmExecutor<(sp_io::SubstrateHostFunctions, EHF)>,
 }
 
-pub fn keypairs_from_private_keys(
-    accounts: &[PrivateKeySigner],
-) -> Result<Vec<Keypair>, subxt_signer::eth::Error> {
-    accounts
-        .iter()
-        .map(|signer| {
-            let key =
-                subxt_signer::eth::Keypair::from_secret_key(signer.credential().to_bytes().into())?;
-            Ok(key)
-        })
-        .collect()
+impl<'a, EHF> FetchRuntimeCode for GenesisBuilderRuntimeCaller<'a, EHF>
+where
+    EHF: HostFunctions,
+{
+    fn fetch_runtime_code(&self) -> Option<Cow<'_, [u8]>> {
+        Some(self.code.as_ref().into())
+    }
+}
+
+impl<'a, EHF> GenesisBuilderRuntimeCaller<'a, EHF>
+where
+    EHF: HostFunctions,
+{
+    fn new(code: &'a [u8]) -> Self {
+        GenesisBuilderRuntimeCaller {
+            code: code.into(),
+            code_hash: blake2_256(code).to_vec(),
+            executor: sc_executor::WasmExecutor::<(sp_io::SubstrateHostFunctions, EHF)>::builder()
+                .with_allow_missing_host_functions(true)
+                .build(),
+        }
+    }
+
+    fn get_storage_for_patch(
+        &self,
+        patch: Value,
+        genesis_storage: Storage,
+    ) -> core::result::Result<Storage, String> {
+        let mut config = self.get_named_preset(None)?;
+        json_patch::merge(&mut config, patch);
+        self.get_storage_for_config(config, genesis_storage)
+    }
+
+    fn call(
+        &self,
+        ext: &mut dyn Externalities,
+        method: &str,
+        data: &[u8],
+    ) -> sc_executor::error::Result<Vec<u8>> {
+        self.executor
+            .call(
+                ext,
+                &RuntimeCode { heap_pages: None, code_fetcher: self, hash: self.code_hash.clone() },
+                method,
+                data,
+                CallContext::Offchain,
+            )
+            .0
+    }
+
+    fn get_named_preset(&self, id: Option<&String>) -> core::result::Result<Value, String> {
+        let mut t = BasicExternalities::new_empty();
+        let call_result = self
+            .call(&mut t, "GenesisBuilder_get_preset", &id.encode())
+            .map_err(|e| format!("wasm call error {e}"))?;
+
+        let named_preset = Option::<Vec<u8>>::decode(&mut &call_result[..])
+            .map_err(|e| format!("scale codec error: {e}"))?;
+
+        if let Some(named_preset) = named_preset {
+            Ok(serde_json::from_slice(&named_preset[..]).expect("returned value is json. qed."))
+        } else {
+            Err(format!("The preset with name {id:?} is not available."))
+        }
+    }
+
+    fn get_storage_for_config(
+        &self,
+        config: Value,
+        genesis_storage: Storage,
+    ) -> core::result::Result<Storage, String> {
+        // This is the key difference compared to the upstream variant, we don't initialise the
+        // storage as empty.
+        let mut ext = BasicExternalities::new(genesis_storage);
+
+        let json_pretty_str = serde_json::to_string_pretty(&config)
+            .map_err(|e| format!("json to string failed: {e}"))?;
+
+        let call_result = self
+            .call(&mut ext, "GenesisBuilder_build_state", &json_pretty_str.encode())
+            .map_err(|e| format!("wasm call error {e}"))?;
+
+        BuildResult::decode(&mut &call_result[..])
+            .map_err(|e| format!("scale codec error: {e}"))?
+            .map_err(|e| format!("{e} for blob:\n{json_pretty_str}"))?;
+
+        Ok(ext.into_storages())
+    }
 }

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

@@ -13,7 +13,7 @@ use polkadot_sdk::{
     sc_client_api::{BlockImportOperation, backend::Backend},
     sc_executor::RuntimeVersionOf,
     sp_blockchain,
-    sp_core::{H160, storage::Storage},
+    sp_core::{self, H160, storage::Storage},
     sp_runtime::{
         BuildStorage,
         traits::{Block as BlockT, Hash as HashT, HashingFor, Header as HeaderT},
@@ -22,6 +22,7 @@ use polkadot_sdk::{
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use std::{collections::BTreeMap, marker::PhantomData, sync::Arc};
+use substrate_runtime::WASM_BINARY;
 use subxt_signer::eth::Keypair;
 
 /// Genesis settings
@@ -46,6 +47,8 @@ pub struct GenesisConfig {
     pub genesis_balance: U256,
     /// Coinbase address
     pub coinbase: Option<Address>,
+    /// Substrate runtime code
+    pub code: Vec<u8>,
 }
 
 impl<'a> From<&'a AnvilNodeConfig> for GenesisConfig {
@@ -67,6 +70,7 @@ impl<'a> From<&'a AnvilNodeConfig> for GenesisConfig {
             genesis_accounts: anvil_config.genesis_accounts.clone(),
             genesis_balance: anvil_config.genesis_balance,
             coinbase: anvil_config.genesis.as_ref().map(|g| g.coinbase),
+            code: WASM_BINARY.expect("Development wasm not available").to_vec(),
         }
     }
 }
@@ -94,8 +98,8 @@ impl GenesisConfig {
             (well_known_keys::TIMESTAMP.to_vec(), self.timestamp.encode()),
             (well_known_keys::BLOCK_NUMBER_KEY.to_vec(), self.number.encode()),
             (well_known_keys::AURA_AUTHORITIES.to_vec(), vec![aura_authority_id].encode()),
+            (sp_core::storage::well_known_keys::CODE.to_vec(), self.code.clone()),
         ];
-        // TODO: add other fields
         storage
     }
 
@@ -185,7 +189,7 @@ impl<Block: BlockT, B: Backend<Block>, E: RuntimeVersionOf>
         )
     }
 
-    pub fn new_with_storage(
+    fn new_with_storage(
         genesis_number: u64,
         genesis_storage: Storage,
         commit_genesis_state: bool,

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

@@ -32,11 +32,16 @@ async fn test_genesis_params() {
 
     // Check that block number, timestamp, and chain id are set correctly at genesis
     assert_eq!(node.best_block_number().await, genesis_block_number);
+    assert_eq!(node.eth_best_block().await.number.as_u32(), genesis_block_number);
+
     let genesis_hash = node.block_hash_by_number(genesis_block_number).await.unwrap();
     // Anvil genesis timestamp is in seconds, while Substrate timestamp is in milliseconds.
     let genesis_timestamp = anvil_genesis_timestamp.checked_mul(1000).unwrap();
     let actual_genesis_timestamp = node.get_decoded_timestamp(Some(genesis_hash)).await;
     assert_eq!(actual_genesis_timestamp, genesis_timestamp);
+    let eth_genesis_timestamp = node.get_eth_timestamp(Some(genesis_hash)).await;
+    assert_eq!(anvil_genesis_timestamp, eth_genesis_timestamp);
+
     let current_chain_id_hex =
         unwrap_response::<String>(node.eth_rpc(EthRequest::EthChainId(())).await.unwrap()).unwrap();
     assert_eq!(current_chain_id_hex, to_hex_string(chain_id));
@@ -49,8 +54,14 @@ async fn test_genesis_params() {
 
     let latest_block_number = node.best_block_number().await;
     assert_eq!(latest_block_number, genesis_block_number + 2);
+    tokio::time::sleep(Duration::from_millis(400)).await;
+    assert_eq!(node.eth_best_block().await.number.as_u32(), genesis_block_number + 2);
+
     let hash2 = node.block_hash_by_number(genesis_block_number + 2).await.unwrap();
     let timestamp2 = node.get_decoded_timestamp(Some(hash2)).await;
+    let eth_timestamp2 = node.get_eth_timestamp(Some(hash2)).await;
+    assert_eq!(eth_timestamp2, timestamp2 / 1000);
+
     assert_with_tolerance(
         timestamp2.saturating_sub(genesis_timestamp),
         2000,
@@ -285,6 +296,8 @@ async fn test_genesis_json() {
         "Genesis block number should match the one in genesis.json"
     );
 
+    assert_eq!(node.eth_best_block().await.number.as_u64(), expected_block_number);
+
     // Test timestamp
     let genesis_hash = node.block_hash_by_number(genesis_block_number).await.unwrap();
     // Anvil genesis timestamp is in seconds, while Substrate timestamp is in milliseconds
@@ -295,6 +308,9 @@ async fn test_genesis_json() {
         "Genesis timestamp should match the one in genesis.json"
     );
 
+    let eth_genesis_timestamp = node.get_eth_timestamp(Some(genesis_hash)).await;
+    assert_eq!(expected_timestamp, eth_genesis_timestamp);
+
     // Test coinbase
     let coinbase =
         unwrap_response::<Address>(node.eth_rpc(EthRequest::EthCoinbase(())).await.unwrap())