From ae2102c94632feb1027307a57b235f884cca1cc3 Mon Sep 17 00:00:00 2001
From: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com>
Date: Fri, 25 Oct 2024 10:42:07 +0200
Subject: [PATCH] `RuntimeGenesiConfig`: json macro added (#5813)

This PR adds `build_struct_json_patch` which helps to generate a JSON
used for preset.

Here is doc and example:

https://github.com/paritytech/polkadot-sdk/blob/d868b858758d3886d16c8ba8feb3c93c188044f3/substrate/frame/support/src/generate_genesis_config.rs#L168-L266

And real-world usage:

https://github.com/paritytech/polkadot-sdk/blob/d868b858758d3886d16c8ba8feb3c93c188044f3/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/genesis_config_presets.rs#L37-L61

Closes #5700

---------

Co-authored-by: Sebastian Kunert <skunert49@gmail.com>
---
 Cargo.lock                                    |   2 +
 .../src/genesis_config_presets.rs             |  17 +-
 .../src/reference_docs/chain_spec_genesis.rs  |  22 +-
 .../chain_spec_runtime/Cargo.toml             |   2 +
 .../chain_spec_runtime/src/pallets.rs         |   2 +-
 .../chain_spec_runtime/src/presets.rs         |  42 +-
 .../tests/chain_spec_builder_tests.rs         |  19 +-
 .../westend/src/genesis_config_presets.rs     |  17 +-
 prdoc/pr_5813.prdoc                           |  18 +
 substrate/frame/support/Cargo.toml            |   1 +
 .../support/src/generate_genesis_config.rs    | 951 ++++++++++++++++++
 substrate/frame/support/src/lib.rs            |   6 +-
 12 files changed, 1044 insertions(+), 55 deletions(-)
 create mode 100644 prdoc/pr_5813.prdoc
 create mode 100644 substrate/frame/support/src/generate_genesis_config.rs

diff --git a/Cargo.lock b/Cargo.lock
index 602891892a2b..335c465e0aa3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2824,6 +2824,7 @@ name = "chain-spec-guide-runtime"
 version = "0.0.0"
 dependencies = [
  "docify",
+ "frame-support",
  "pallet-balances",
  "pallet-sudo",
  "pallet-timestamp",
@@ -6442,6 +6443,7 @@ dependencies = [
 name = "frame-support"
 version = "28.0.0"
 dependencies = [
+ "Inflector",
  "aquamarine",
  "array-bytes",
  "assert_matches",
diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/genesis_config_presets.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/genesis_config_presets.rs
index dc98d00f8f63..d15dd971a819 100644
--- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/genesis_config_presets.rs
+++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/genesis_config_presets.rs
@@ -18,6 +18,7 @@
 use crate::*;
 use alloc::{vec, vec::Vec};
 use cumulus_primitives_core::ParaId;
+use frame_support::build_struct_json_patch;
 use hex_literal::hex;
 use parachains_common::{AccountId, AuraId};
 use sp_core::crypto::UncheckedInto;
@@ -33,15 +34,14 @@ fn asset_hub_rococo_genesis(
 	endowment: Balance,
 	id: ParaId,
 ) -> serde_json::Value {
-	let config = RuntimeGenesisConfig {
+	build_struct_json_patch!(RuntimeGenesisConfig {
 		balances: BalancesConfig {
 			balances: endowed_accounts.iter().cloned().map(|k| (k, endowment)).collect(),
 		},
-		parachain_info: ParachainInfoConfig { parachain_id: id, ..Default::default() },
+		parachain_info: ParachainInfoConfig { parachain_id: id },
 		collator_selection: CollatorSelectionConfig {
 			invulnerables: invulnerables.iter().cloned().map(|(acc, _)| acc).collect(),
 			candidacy_bond: ASSET_HUB_ROCOCO_ED * 16,
-			..Default::default()
 		},
 		session: SessionConfig {
 			keys: invulnerables
@@ -54,16 +54,9 @@ fn asset_hub_rococo_genesis(
 					)
 				})
 				.collect(),
-			..Default::default()
 		},
-		polkadot_xcm: PolkadotXcmConfig {
-			safe_xcm_version: Some(SAFE_XCM_VERSION),
-			..Default::default()
-		},
-		..Default::default()
-	};
-
-	serde_json::to_value(config).expect("Could not build genesis config.")
+		polkadot_xcm: PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION) },
+	})
 }
 
 /// Encapsulates names of predefined presets.
diff --git a/docs/sdk/src/reference_docs/chain_spec_genesis.rs b/docs/sdk/src/reference_docs/chain_spec_genesis.rs
index 3326f433f288..b7a0a648d0cf 100644
--- a/docs/sdk/src/reference_docs/chain_spec_genesis.rs
+++ b/docs/sdk/src/reference_docs/chain_spec_genesis.rs
@@ -100,17 +100,22 @@
 //! others useful for testing.
 //!
 //! Internally, presets can be provided in a number of ways:
-//! - JSON in string form:
-#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_1)]
-//! - JSON using runtime types to serialize values:
+//! - using [`build_struct_json_patch`] macro (**recommended**):
 #![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_2)]
+//! - JSON using runtime types to serialize values:
 #![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_3)]
+//! - JSON in string form:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_1)]
+//!
 //! It is worth noting that a preset does not have to be the full `RuntimeGenesisConfig`, in that
 //! sense that it does not have to contain all the keys of the struct. The preset is actually a JSON
 //! patch that will be merged with the default value of `RuntimeGenesisConfig`. This approach should
 //! simplify maintenance of built-in presets. The following example illustrates a runtime genesis
-//! config patch:
+//! config patch with a single key built using [`build_struct_json_patch`] macro:
 #![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_4)]
+//! This results in the following JSON blob:
+#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", preset_4_json)]
+//!
 //!
 //! ## Note on the importance of testing presets
 //!
@@ -122,8 +127,8 @@
 //!
 //! ## Note on the importance of using the `deny_unknown_fields` attribute
 //!
-//! It is worth noting that it is easy to make a hard-to-spot mistake, as in the following example
-//! ([`FooStruct`] does not contain `fieldC`):
+//! It is worth noting that when manually building preset JSON blobs it is easy to make a
+//! hard-to-spot mistake, as in the following example ([`FooStruct`] does not contain `fieldC`):
 #![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_invalid)]
 //! Even though `preset_invalid` contains a key that does not exist, the deserialization of the JSON
 //! blob does not fail. The misspelling is silently ignored due to the lack of the
@@ -131,6 +136,10 @@
 //! `GenesisConfig`.
 #![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", invalid_preset_works)]
 //!
+//! To avoid this problem [`build_struct_json_patch`] macro shall be used whenever possible (it
+//! internally instantiates the struct before serializang it JSON blob, so all unknown fields shall
+//! be caught at compilation time).
+//!
 //! ## Runtime `GenesisConfig` raw format
 //!
 //! A raw format of genesis config contains just the state's keys and values as they are stored in
@@ -182,6 +191,7 @@
 //! [`get_preset`]: frame_support::genesis_builder_helper::get_preset
 //! [`pallet::genesis_build`]: frame_support::pallet_macros::genesis_build
 //! [`pallet::genesis_config`]: frame_support::pallet_macros::genesis_config
+//! [`build_struct_json_patch`]: frame_support::build_struct_json_patch
 //! [`BuildGenesisConfig`]: frame_support::traits::BuildGenesisConfig
 //! [`serde`]: https://serde.rs/field-attrs.html
 //! [`get_storage_for_patch`]: sc_chain_spec::GenesisConfigBuilderRuntimeCaller::get_storage_for_patch
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml
index 028495712032..07c0342f5fbe 100644
--- a/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml
@@ -12,6 +12,7 @@ publish = false
 [dependencies]
 docify = { workspace = true }
 codec = { workspace = true }
+frame-support = { workspace = true }
 scale-info = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
@@ -49,6 +50,7 @@ std = [
 	"codec/std",
 	"scale-info/std",
 
+	"frame-support/std",
 	"frame/std",
 
 	"pallet-balances/std",
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs
index 2ff2d9539e2d..571632ecd272 100644
--- a/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs
@@ -118,7 +118,7 @@ pub mod pallet_foo {
 		pub some_enum: FooEnum,
 		pub some_struct: FooStruct,
 		#[serde(skip)]
-		_phantom: PhantomData<T>,
+		pub _phantom: PhantomData<T>,
 	}
 
 	#[pallet::genesis_build]
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs
index 02c2d90f7c82..c1316b2f8734 100644
--- a/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs
@@ -17,8 +17,12 @@
 
 //! Presets for the chain-spec demo runtime.
 
-use crate::pallets::{FooEnum, SomeFooData1, SomeFooData2};
+use crate::{
+	pallets::{FooEnum, SomeFooData1, SomeFooData2},
+	runtime::{BarConfig, FooConfig, RuntimeGenesisConfig},
+};
 use alloc::vec;
+use frame_support::build_struct_json_patch;
 use serde_json::{json, to_string, Value};
 use sp_application_crypto::Ss58Codec;
 use sp_keyring::AccountKeyring;
@@ -27,7 +31,7 @@ use sp_keyring::AccountKeyring;
 pub const PRESET_1: &str = "preset_1";
 /// A demo preset with real types.
 pub const PRESET_2: &str = "preset_2";
-/// Another demo preset with real types.
+/// Another demo preset with real types and manually created json object.
 pub const PRESET_3: &str = "preset_3";
 /// A single value patch preset.
 pub const PRESET_4: &str = "preset_4";
@@ -58,21 +62,21 @@ fn preset_1() -> Value {
 }
 
 #[docify::export]
-/// Function provides a preset demonstrating how use the actual types to create a preset.
+/// Function provides a preset demonstrating how to create a preset using
+/// [`build_struct_json_patch`] macro.
 fn preset_2() -> Value {
-	json!({
-		"bar": {
-			"initialAccount": AccountKeyring::Ferdie.public().to_ss58check(),
-		},
-		"foo": {
-			"someEnum": FooEnum::Data2(SomeFooData2 { values: vec![12,16] }),
-			"someInteger": 200
+	build_struct_json_patch!(RuntimeGenesisConfig {
+		foo: FooConfig {
+			some_integer: 200,
+			some_enum: FooEnum::Data2(SomeFooData2 { values: vec![0x0c, 0x10] })
 		},
+		bar: BarConfig { initial_account: Some(AccountKeyring::Ferdie.public().into()) },
 	})
 }
 
 #[docify::export]
-/// Function provides a preset demonstrating how use the actual types to create a preset.
+/// Function provides a preset demonstrating how use the actual types to manually create a JSON
+/// representing the preset.
 fn preset_3() -> Value {
 	json!({
 		"bar": {
@@ -92,22 +96,16 @@ fn preset_3() -> Value {
 
 #[docify::export]
 /// Function provides a minimal preset demonstrating how to patch single key in
-/// `RuntimeGenesisConfig`.
-fn preset_4() -> Value {
-	json!({
-		"foo": {
-			"someEnum": {
-				"Data2": {
-					"values": "0x0c0f"
-				}
-			},
-		},
+/// `RuntimeGenesisConfig` using [`build_struct_json_patch`] macro.
+pub fn preset_4() -> Value {
+	build_struct_json_patch!(RuntimeGenesisConfig {
+		foo: FooConfig { some_enum: FooEnum::Data2(SomeFooData2 { values: vec![0x0c, 0x10] }) },
 	})
 }
 
 #[docify::export]
 /// Function provides an invalid preset demonstrating how important is use of
-/// [`deny_unknown_fields`] in data structures used in `GenesisConfig`.
+/// `deny_unknown_fields` in data structures used in `GenesisConfig`.
 fn preset_invalid() -> Value {
 	json!({
 		"foo": {
diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs
index cc273685fcb4..c2fe5a6727e6 100644
--- a/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs
+++ b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs
@@ -58,7 +58,7 @@ fn get_preset() {
 
 	let output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
 
-	//note: copy of chain_spec_guide_runtime::preset_1
+	//note: copy of chain_spec_guide_runtime::preset_2
 	let expected_output = json!({
 		"bar": {
 			"initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL",
@@ -186,3 +186,20 @@ fn generate_para_chain_spec() {
 	});
 	assert_eq!(output, expected_output, "Output did not match expected");
 }
+
+#[test]
+#[docify::export]
+fn preset_4_json() {
+	assert_eq!(
+		chain_spec_guide_runtime::presets::preset_4(),
+		json!({
+			"foo": {
+				"someEnum": {
+					"Data2": {
+						"values": "0x0c10"
+					}
+				},
+			},
+		})
+	);
+}
diff --git a/polkadot/runtime/westend/src/genesis_config_presets.rs b/polkadot/runtime/westend/src/genesis_config_presets.rs
index 621ef38f0b75..a9e22898ddb4 100644
--- a/polkadot/runtime/westend/src/genesis_config_presets.rs
+++ b/polkadot/runtime/westend/src/genesis_config_presets.rs
@@ -23,6 +23,7 @@ use crate::{
 #[cfg(not(feature = "std"))]
 use alloc::format;
 use alloc::{vec, vec::Vec};
+use frame_support::build_struct_json_patch;
 use pallet_staking::{Forcing, StakerStatus};
 use polkadot_primitives::{AccountId, AssignmentId, SchedulerParams, ValidatorId};
 use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
@@ -170,7 +171,7 @@ fn westend_testnet_genesis(
 	const ENDOWMENT: u128 = 1_000_000 * WND;
 	const STASH: u128 = 100 * WND;
 
-	let config = RuntimeGenesisConfig {
+	build_struct_json_patch!(RuntimeGenesisConfig {
 		balances: BalancesConfig {
 			balances: endowed_accounts.iter().map(|k| (k.clone(), ENDOWMENT)).collect::<Vec<_>>(),
 		},
@@ -192,7 +193,6 @@ fn westend_testnet_genesis(
 					)
 				})
 				.collect::<Vec<_>>(),
-			..Default::default()
 		},
 		staking: StakingConfig {
 			minimum_validator_count: 1,
@@ -204,19 +204,12 @@ fn westend_testnet_genesis(
 			invulnerables: initial_authorities.iter().map(|x| x.0.clone()).collect::<Vec<_>>(),
 			force_era: Forcing::NotForcing,
 			slash_reward_fraction: Perbill::from_percent(10),
-			..Default::default()
 		},
-		babe: BabeConfig { epoch_config: BABE_GENESIS_EPOCH_CONFIG, ..Default::default() },
+		babe: BabeConfig { epoch_config: BABE_GENESIS_EPOCH_CONFIG },
 		sudo: SudoConfig { key: Some(root_key) },
 		configuration: ConfigurationConfig { config: default_parachains_host_configuration() },
-		registrar: RegistrarConfig {
-			next_free_para_id: polkadot_primitives::LOWEST_PUBLIC_ID,
-			..Default::default()
-		},
-		..Default::default()
-	};
-
-	serde_json::to_value(config).expect("Could not build genesis config.")
+		registrar: RegistrarConfig { next_free_para_id: polkadot_primitives::LOWEST_PUBLIC_ID },
+	})
 }
 
 // staging_testnet
diff --git a/prdoc/pr_5813.prdoc b/prdoc/pr_5813.prdoc
new file mode 100644
index 000000000000..e48f29bbfb63
--- /dev/null
+++ b/prdoc/pr_5813.prdoc
@@ -0,0 +1,18 @@
+title: "build_struct_json_patch macro added"
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      This PR adds a macro that allows to construct a RuntimeGenesisConfig preset 
+      containing only provided fields, while performing the validation of the
+      entire struct.
+
+      Related issue: https://github.com/paritytech/polkadot-sdk/issues/5700
+
+crates:
+  - name: frame-support
+    bump: minor
+  - name: asset-hub-rococo-runtime
+    bump: patch
+  - name: westend-runtime
+    bump: patch
diff --git a/substrate/frame/support/Cargo.toml b/substrate/frame/support/Cargo.toml
index 18ca4a3acdab..d7da034b3492 100644
--- a/substrate/frame/support/Cargo.toml
+++ b/substrate/frame/support/Cargo.toml
@@ -71,6 +71,7 @@ pretty_assertions = { workspace = true }
 sp-timestamp = { workspace = true }
 frame-system = { workspace = true, default-features = true }
 sp-crypto-hashing = { workspace = true, default-features = true }
+Inflector = { workspace = true }
 
 [features]
 default = ["std"]
diff --git a/substrate/frame/support/src/generate_genesis_config.rs b/substrate/frame/support/src/generate_genesis_config.rs
new file mode 100644
index 000000000000..fc21e76c7427
--- /dev/null
+++ b/substrate/frame/support/src/generate_genesis_config.rs
@@ -0,0 +1,951 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Helper macro allowing to construct JSON representation of partially initialized structs.
+
+use serde_json::Value;
+extern crate alloc;
+use alloc::{borrow::Cow, format, string::String};
+
+/// Represents the initialization method of a field within a struct.
+///
+/// This enum provides information about how it was initialized and the field name (as a `String`).
+///
+/// Intended to be used in `build_struct_json_patch` macro.
+#[derive(Debug)]
+pub enum InitializedField<'a> {
+	/// The field was partially initialized (e.g., specific fields within the struct were set
+	/// manually).
+	Partial(Cow<'a, str>),
+	/// The field was fully initialized (e.g., using `new()` or `default()` like methods).
+	Full(Cow<'a, str>),
+}
+
+impl<'a> InitializedField<'a> {
+	/// Returns a name of the field.
+	pub fn get_name(&'a self) -> &'a str {
+		match self {
+			Self::Partial(s) | Self::Full(s) => s,
+		}
+	}
+
+	/// Injects a prefix to the field name.
+	pub fn add_prefix(&mut self, prefix: &str) {
+		match self {
+			Self::Partial(s) | Self::Full(s) => *s = format!("{prefix}.{s}").into(),
+		};
+	}
+
+	/// Creates new partial field instiance.
+	pub fn partial(s: &'a str) -> Self {
+		Self::Partial(s.into())
+	}
+
+	/// Creates new full field instiance.
+	pub fn full(s: &'a str) -> Self {
+		Self::Full(s.into())
+	}
+}
+
+impl PartialEq<String> for InitializedField<'_> {
+	fn eq(&self, other: &String) -> bool {
+		#[inline]
+		/// We need to respect the `camelCase` naming for field names. This means that
+		/// `"camelCaseKey"` should be considered equal to `"camel_case_key"`. This
+		/// function implements this comparison.
+		fn compare_keys(ident_chars: core::str::Chars, camel_chars: core::str::Chars) -> bool {
+			ident_chars
+				.filter(|c| *c != '_')
+				.map(|c| c.to_ascii_uppercase())
+				.eq(camel_chars.map(|c| c.to_ascii_uppercase()))
+		}
+		match self {
+			InitializedField::Partial(field_name) | InitializedField::Full(field_name) =>
+				field_name == other || compare_keys(field_name.chars(), other.chars()),
+		}
+	}
+}
+
+/// Recursively removes keys from provided `json_value` object, retaining only specified keys.
+///
+/// This function modifies the provided `json_value` in-place, keeping only the keys listed in
+/// `keys_to_retain`. The keys are matched recursively by combining the current key with
+/// the `current_root`, allowing for nested field retention.
+///
+/// Keys marked as `Full`, are retained as-is. For keys marked as `Partial`, the
+/// function recurses into nested objects to retain matching subfields.
+///
+/// Function respects the `camelCase` serde_json attribute for structures. This means that
+/// `"camelCaseKey"` key will be retained in JSON blob if `"camel_case_key"` exists in
+/// `keys_to_retain`.
+///
+/// Intended to be used from `build_struct_json_patch` macro.
+pub fn retain_initialized_fields(
+	json_value: &mut Value,
+	keys_to_retain: &[InitializedField],
+	current_root: String,
+) {
+	if let serde_json::Value::Object(ref mut map) = json_value {
+		map.retain(|key, value| {
+			let current_key =
+				if current_root.is_empty() { key.clone() } else { format!("{current_root}.{key}") };
+			match keys_to_retain.iter().find(|key| **key == current_key) {
+				Some(InitializedField::Full(_)) => true,
+				Some(InitializedField::Partial(_)) => {
+					retain_initialized_fields(value, keys_to_retain, current_key.clone());
+					true
+				},
+				None => false,
+			}
+		})
+	}
+}
+
+/// Creates a JSON patch for given `struct_type`, supporting recursive field initialization.
+///
+/// This macro creates a default `struct_type`, initializing specified fields (which can be nested)
+/// with the provided values. Any fields not explicitly given are initialized with their default
+/// values. The macro then serializes the fully initialized structure into a JSON blob, retaining
+/// only the fields that were explicitly provided, either partially or fully initialized.
+///
+/// Using this macro prevents errors from manually creating JSON objects, such as typos or
+/// inconsistencies with the `struct_type` structure, by relying on the actual
+/// struct definition. This ensures the generated JSON is valid and reflects any future changes
+/// to the structure.
+///
+/// # Example
+///
+/// ```rust
+/// use frame_support::build_struct_json_patch;
+/// #[derive(Default, serde::Serialize, serde::Deserialize)]
+/// #[serde(rename_all = "camelCase")]
+/// struct RuntimeGenesisConfig {
+///     a_field: u32,
+///     b_field: B,
+///     c_field: u32,
+/// }
+///
+/// #[derive(Default, serde::Serialize, serde::Deserialize)]
+/// #[serde(rename_all = "camelCase")]
+/// struct B {
+/// 	i_field: u32,
+/// 	j_field: u32,
+/// }
+/// impl B {
+/// 	fn new() -> Self {
+/// 		Self { i_field: 0, j_field: 2 }
+/// 	}
+/// }
+///
+/// assert_eq!(
+/// 	build_struct_json_patch! ( RuntimeGenesisConfig {
+/// 		a_field: 66,
+/// 	}),
+/// 	serde_json::json!({
+/// 			"aField": 66,
+/// 	})
+/// );
+///
+/// assert_eq!(
+/// 	build_struct_json_patch! ( RuntimeGenesisConfig {
+/// 		//"partial" initialization of `b_field`
+/// 		b_field: B {
+/// 			i_field: 2,
+/// 		}
+/// 	}),
+/// 	serde_json::json!({
+/// 		"bField": {"iField": 2}
+/// 	})
+/// );
+///
+/// assert_eq!(
+/// 	build_struct_json_patch! ( RuntimeGenesisConfig {
+/// 		a_field: 66,
+/// 		//"full" initialization of `b_field`
+/// 		b_field: B::new()
+/// 	}),
+/// 	serde_json::json!({
+/// 		"aField": 66,
+/// 		"bField": {"iField": 0, "jField": 2}
+/// 	})
+/// );
+/// ```
+///
+/// In this example:
+/// ```ignore
+/// 	build_struct_json_patch! ( RuntimeGenesisConfig {
+/// 		b_field: B {
+/// 			i_field: 2,
+/// 		}
+/// 	}),
+/// ```
+/// `b_field` is partially initialized, it will be expanded to:
+/// ```ignore
+/// RuntimeGenesisConfig {
+/// 		b_field {
+/// 			i_field: 2,
+/// 			..Default::default()
+/// 		},
+/// 		..Default::default()
+/// }
+/// ```
+/// While all other fields are initialized with default values. The macro serializes this, retaining
+/// only the provided fields.
+#[macro_export]
+macro_rules! build_struct_json_patch {
+	(
+		$($struct_type:ident)::+ { $($tail:tt)* }
+	) => {
+		{
+			let mut keys = $crate::__private::Vec::<$crate::generate_genesis_config::InitializedField>::default();
+			#[allow(clippy::needless_update)]
+			let struct_instance = $crate::build_struct_json_patch!($($struct_type)::+, keys @  { $($tail)* });
+			let mut json_value =
+				$crate::__private::serde_json::to_value(struct_instance).expect("serialization to json should work. qed");
+			$crate::generate_genesis_config::retain_initialized_fields(&mut json_value, &keys, Default::default());
+			json_value
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident @ { $($tail:tt)* }) => {
+		$($struct_type)::+ {
+			..$crate::build_struct_json_patch!($($struct_type)::+, $all_keys @ $($tail)*)
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident  @  $key:ident: $($type:ident)::+ { $keyi:ident : $value:tt }  ) => {
+		$($struct_type)::+ {
+			$key: {
+				$all_keys.push($crate::generate_genesis_config::InitializedField::partial(stringify!($key)));
+				$all_keys.push(
+					$crate::generate_genesis_config::InitializedField::full(concat!(stringify!($key), ".", stringify!($keyi)))
+				);
+				$($type)::+ {
+					$keyi:$value,
+					..Default::default()
+				}
+			},
+			..Default::default()
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident  @  $key:ident:  $($type:ident)::+ { $($body:tt)* } ) => {
+		$($struct_type)::+ {
+			$key: {
+				$all_keys.push($crate::generate_genesis_config::InitializedField::partial(stringify!($key)));
+				let mut inner_keys = $crate::__private::Vec::<$crate::generate_genesis_config::InitializedField>::default();
+				let value = $crate::build_struct_json_patch!($($type)::+, inner_keys @ { $($body)* });
+				for i in inner_keys.iter_mut() {
+					i.add_prefix(stringify!($key));
+				};
+				$all_keys.extend(inner_keys);
+				value
+			},
+			..Default::default()
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident  @  $key:ident:  $($type:ident)::+ { $($body:tt)* },  $($tail:tt)*  ) => {
+		$($struct_type)::+ {
+			$key : {
+				$all_keys.push($crate::generate_genesis_config::InitializedField::partial(stringify!($key)));
+				let mut inner_keys = $crate::__private::Vec::<$crate::generate_genesis_config::InitializedField>::default();
+				let value = $crate::build_struct_json_patch!($($type)::+, inner_keys @ { $($body)* });
+				for i in inner_keys.iter_mut() {
+					i.add_prefix(stringify!($key));
+				};
+				$all_keys.extend(inner_keys);
+				value
+			},
+			.. $crate::build_struct_json_patch!($($struct_type)::+, $all_keys @ $($tail)*)
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident  @  $key:ident: $value:expr, $($tail:tt)* ) => {
+		$($struct_type)::+ {
+			$key: {
+				$all_keys.push($crate::generate_genesis_config::InitializedField::full(stringify!($key)));
+				$value
+			},
+			..$crate::build_struct_json_patch!($($struct_type)::+, $all_keys @ $($tail)*)
+		}
+	};
+	($($struct_type:ident)::+, $all_keys:ident  @  $key:ident: $value:expr ) => {
+		$($struct_type)::+ {
+			$key: {
+				$all_keys.push($crate::generate_genesis_config::InitializedField::full(stringify!($key)));
+				$value
+			},
+			..Default::default()
+		}
+	};
+
+	($($struct_type:ident)::+, $all_keys:ident  @ $(,)?) => {
+		$($struct_type)::+ { ..Default::default() }
+	};
+}
+
+#[cfg(test)]
+mod test {
+	mod nested_mod {
+		#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+		pub struct InsideMod {
+			pub a: u32,
+			pub b: u32,
+		}
+
+		pub mod nested_mod2 {
+			pub mod nested_mod3 {
+				#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+				pub struct InsideMod3 {
+					pub a: u32,
+					pub b: u32,
+					pub s: super::super::InsideMod,
+				}
+			}
+		}
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct TestStruct {
+		a: u32,
+		b: u32,
+		s: S,
+		s3: S3,
+		t3: S3,
+		i: Nested1,
+		e: E,
+		t: nested_mod::InsideMod,
+		u: nested_mod::nested_mod2::nested_mod3::InsideMod3,
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct S {
+		x: u32,
+	}
+
+	impl S {
+		fn new(c: u32) -> Self {
+			Self { x: c }
+		}
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct E(u8);
+
+	#[derive(Default, Debug, serde::Serialize, serde::Deserialize)]
+	enum SomeEnum<T> {
+		#[default]
+		A,
+		B(T),
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct S3 {
+		x: u32,
+		y: u32,
+		z: u32,
+	}
+
+	impl S3 {
+		fn new(c: u32) -> Self {
+			Self { x: c, y: c, z: c }
+		}
+
+		fn new_from_s(s: S) -> Self {
+			Self { x: s.x, ..Default::default() }
+		}
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct Nested3 {
+		a: u32,
+		b: u32,
+		s: S,
+		v: Vec<(u32, u32, u32, SomeEnum<u32>)>,
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct Nested2 {
+		a: u32,
+		iii: Nested3,
+		v: Vec<u32>,
+		s3: S3,
+	}
+
+	impl Nested2 {
+		fn new(a: u32) -> Self {
+			Nested2 {
+				a,
+				v: vec![a, a, a],
+				iii: Nested3 { a, b: a, ..Default::default() },
+				s3: S3 { x: a, ..Default::default() },
+			}
+		}
+	}
+
+	#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
+	struct Nested1 {
+		a: u32,
+		ii: Nested2,
+	}
+
+	macro_rules! test {
+		($($struct:ident)::+ { $($v:tt)* }, { $($j:tt)* } ) => {{
+			println!("--");
+			let expected = serde_json::json!({ $($j)* });
+			println!("json: {}", serde_json::to_string_pretty(&expected).unwrap());
+			let value = build_struct_json_patch!($($struct)::+ { $($v)* });
+			println!("gc: {}", serde_json::to_string_pretty(&value).unwrap());
+			assert_eq!(value, expected);
+		}};
+	}
+
+	#[test]
+	fn test_generate_config_macro() {
+		let t = 5;
+		const C: u32 = 5;
+		test!(TestStruct { b: 5 }, { "b": 5 });
+		#[allow(unused_braces)]
+		{
+			test!(TestStruct { b: { 4 + 34 } } , { "b": 38 });
+		}
+		test!(TestStruct { s: S { x: 5 } }, { "s": { "x": 5 } });
+		test!(
+			TestStruct { s: S::new(C) },
+			{
+				"s": { "x": 5 }
+			}
+		);
+		test!(
+			TestStruct { s: S { x: t } },
+			{
+				"s": { "x": t }
+			}
+		);
+		test!(
+			TestStruct {
+				b: 5,
+				s: S { x: t }
+			},
+			{
+				"b": 5,
+				"s": { "x": 5 }
+			}
+		);
+		test!(
+			TestStruct { s: S::new(C), b: 5 },
+			{
+				"s": { "x": 5 }, "b": 5
+			}
+		);
+		test!(
+			TestStruct { s3: S3 { x: t } },
+			{
+				"s3": { "x": 5 }
+			}
+		);
+		test!(
+			TestStruct {
+				s3: S3 { x: t, y: 2 }
+			},
+			{
+				"s3": { "x": 5, "y": 2 }
+			}
+		);
+		// //
+		test!(
+			TestStruct {
+				s3: S3 { x: t, y: 2 },
+				t3: S3 { x: 2 }
+			},
+			{
+				"s3": { "x": t, "y": 2 },
+				"t3": { "x": 2 }
+			}
+
+		);
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 { iii: Nested3 { a: 2 } }
+				}
+			}
+			,
+			{
+				"i":  {
+					"ii": { "iii": { "a": 2 } }
+				}
+			}
+
+		);
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 { a: 2, s: S::new(C) }
+					}
+				}
+			},
+			{
+				"i": {
+					"ii": {
+						"iii": { "a": 2, "s": { "x": 5} }
+					}
+				}
+			}
+		);
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 { s: S::new(C), a: 2 }
+					},
+					a: 44
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4
+			},
+			{
+				"i": {
+					"ii": {
+						"iii": { "a": 2, "s": { "x": 5} }
+					},
+					"a": 44
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2::new(66),
+					a: 44,
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4
+			},
+			{
+				"i": {
+					"ii": {
+						"a": 66,
+						"s3": { "x":66, "y": 0, "z": 0 },
+						"iii": { "a": 66,"b":66, "s": { "x": 0 }, "v": Vec::<u32>::default() },
+						"v": vec![66,66,66]
+					},
+					"a": 44
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						a: 66,
+						s3: S3 { x: 66 },
+						iii: Nested3 {
+							a: 66,b:66
+						},
+						v: vec![66,66,66]
+					},
+					a: 44,
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4
+			},
+			{
+				"i": {
+					"ii": {
+						"a": 66,
+						"s3": { "x":66,  },
+						"iii": { "a": 66,"b":66, },
+						"v": vec![66,66,66]
+					},
+					"a": 44
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 { a: 2, s: S::new(C) },
+					},
+					a: 44,
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4,
+			},
+			{
+				"i": {
+					"ii": {
+						"iii": { "a": 2, "s": { "x": 5 } },
+					},
+					"a" : 44,
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						s3: S3::new(5),
+						iii: Nested3 { a: 2, s: S::new(C) },
+					},
+					a: 44,
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4,
+			},
+			{
+				"i": {
+					"ii": {
+						"iii": { "a": 2, "s": { "x": 5 } },
+						"s3": {"x": 5, "y": 5, "z": 5 }
+					},
+					"a" : 44,
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+		test!(
+			TestStruct {
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4,
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 { a: 2, s: S::new(C) },
+						s3: S3::new_from_s(S { x: 4 })
+					},
+					a: 44,
+				}
+			},
+			{
+				"i": {
+					"ii": {
+						"iii": { "a": 2, "s": { "x": 5 } },
+						"s3": {"x": 4, "y": 0, "z": 0 }
+					},
+					"a" : 44,
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+		let i = [0u32, 1u32, 2u32];
+		test!(
+			TestStruct {
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 {
+							a: 2,
+							s: S::new(C),
+							v: i.iter()
+								.map(|x| (*x, 2 * x, 100 + x, SomeEnum::<u32>::A))
+								.collect::<Vec<_>>(),
+						},
+						s3: S3::new_from_s(S { x: 4 })
+					},
+					a: 44,
+				},
+				a: 3,
+				s3: S3 { x: 5 },
+				b: 4,
+			},
+
+			{
+				"i": {
+					"ii": {
+						"iii": {
+							"a": 2,
+							"s": { "x": 5 },
+							"v": i.iter()
+								.map(|x| (*x, 2 * x, 100 + x, SomeEnum::<u32>::A))
+								.collect::<Vec<_>>(),
+						},
+						"s3": {"x": 4, "y": 0, "z": 0 }
+					},
+					"a" : 44,
+				},
+				"a": 3,
+				"s3": { "x": 5 },
+				"b": 4
+			}
+		);
+	}
+
+	#[test]
+	fn test_generate_config_macro_with_nested_mods() {
+		test!(
+			TestStruct { t: nested_mod::InsideMod { a: 32 } },
+			{
+				"t" : { "a": 32 }
+			}
+		);
+		test!(
+			TestStruct {
+				t: nested_mod::InsideMod { a: 32 },
+				u: nested_mod::nested_mod2::nested_mod3::InsideMod3 { a: 32 }
+			},
+			{
+				"t" : { "a": 32 },
+				"u" : { "a": 32 }
+			}
+		);
+		test!(
+			TestStruct {
+				t: nested_mod::InsideMod { a: 32 },
+				u: nested_mod::nested_mod2::nested_mod3::InsideMod3 {
+					a: 32,
+					s: nested_mod::InsideMod { a: 34 },
+				}
+			},
+			{
+				"t" : { "a": 32 },
+				"u" : { "a": 32, "s": { "a": 34 } }
+			}
+		);
+		test!(
+			TestStruct {
+				t: nested_mod::InsideMod { a: 32 },
+				u: nested_mod::nested_mod2::nested_mod3::InsideMod3::default()
+			},
+			{
+				"t" : { "a": 32 },
+				"u" : { "a": 0, "b": 0,  "s": { "a": 0, "b": 0} }
+			}
+		);
+
+		let i = [0u32, 1u32, 2u32];
+		const C: u32 = 5;
+		test!(
+			TestStruct {
+				t: nested_mod::InsideMod { a: 32 },
+				u: nested_mod::nested_mod2::nested_mod3::InsideMod3::default(),
+				i: Nested1 {
+					ii: Nested2 {
+						iii: Nested3 {
+							a: 2,
+							s: S::new(C),
+							v: i.iter()
+								.map(|x| (*x, 2 * x, 100 + x, SomeEnum::<u32>::A))
+								.collect::<Vec<_>>(),
+						},
+						s3: S3::new_from_s(S { x: 4 })
+					},
+					a: 44,
+				},
+			},
+			{
+				"t" : { "a": 32 },
+				"u" : { "a": 0, "b": 0,  "s": { "a": 0, "b": 0} } ,
+				"i": {
+					"ii": {
+						"iii": {
+							"a": 2,
+							"s": { "x": 5 },
+							"v": i.iter()
+								.map(|x| (*x, 2 * x, 100 + x, SomeEnum::<u32>::A))
+								.collect::<Vec<_>>(),
+						},
+						"s3": {"x": 4, "y": 0, "z": 0 }
+					},
+					"a" : 44,
+				},
+			}
+		);
+	}
+}
+
+#[cfg(test)]
+mod retain_keys_test {
+	use super::*;
+	use serde_json::json;
+
+	macro_rules! check_initialized_field_eq_cc(
+		( $s:literal ) => {
+			let field = InitializedField::full($s);
+			let cc = inflector::cases::camelcase::to_camel_case($s);
+			println!("field: {:?}, cc: {}", field, cc);
+			assert_eq!(field,cc);
+		} ;
+		( &[ $f:literal $(, $r:literal)* ]) => {
+			let field = InitializedField::full(
+				concat!( $f $(,".",$r)+ )
+			);
+			let cc = [ $f $(,$r)+  ].into_iter()
+				.map(|s| inflector::cases::camelcase::to_camel_case(s))
+				.collect::<Vec<_>>()
+				.join(".");
+			println!("field: {:?}, cc: {}", field, cc);
+			assert_eq!(field,cc);
+		} ;
+	);
+
+	#[test]
+	fn test_initialized_field_eq_cc_string() {
+		check_initialized_field_eq_cc!("a_");
+		check_initialized_field_eq_cc!("abc");
+		check_initialized_field_eq_cc!("aBc");
+		check_initialized_field_eq_cc!("aBC");
+		check_initialized_field_eq_cc!("ABC");
+		check_initialized_field_eq_cc!("2abs");
+		check_initialized_field_eq_cc!("2Abs");
+		check_initialized_field_eq_cc!("2ABs");
+		check_initialized_field_eq_cc!("2aBs");
+		check_initialized_field_eq_cc!("AlreadyCamelCase");
+		check_initialized_field_eq_cc!("alreadyCamelCase");
+		check_initialized_field_eq_cc!("C");
+		check_initialized_field_eq_cc!("1a");
+		check_initialized_field_eq_cc!("_1a");
+		check_initialized_field_eq_cc!("a_b");
+		check_initialized_field_eq_cc!("_a_b");
+		check_initialized_field_eq_cc!("a___b");
+		check_initialized_field_eq_cc!("__a_b");
+		check_initialized_field_eq_cc!("_a___b_C");
+		check_initialized_field_eq_cc!("__A___B_C");
+		check_initialized_field_eq_cc!(&["a_b", "b_c"]);
+		check_initialized_field_eq_cc!(&["al_pha", "_a___b_C"]);
+		check_initialized_field_eq_cc!(&["al_pha_", "_a___b_C"]);
+		check_initialized_field_eq_cc!(&["first_field", "al_pha_", "_a___b_C"]);
+		check_initialized_field_eq_cc!(&["al_pha_", "__2nd_field", "_a___b_C"]);
+		check_initialized_field_eq_cc!(&["al_pha_", "__2nd3and_field", "_a___b_C"]);
+		check_initialized_field_eq_cc!(&["_a1", "_a2", "_a3_"]);
+	}
+
+	#[test]
+	fn test01() {
+		let mut v = json!({
+			"a":1
+		});
+		let e = v.clone();
+		retain_initialized_fields(&mut v, &[InitializedField::full("a")], String::default());
+		assert_eq!(e, v);
+	}
+
+	#[test]
+	fn test02() {
+		let mut v = json!({
+			"a":1
+		});
+		retain_initialized_fields(&mut v, &[InitializedField::full("b")], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test03() {
+		let mut v = json!({});
+		retain_initialized_fields(&mut v, &[], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test04() {
+		let mut v = json!({});
+		retain_initialized_fields(&mut v, &[InitializedField::full("b")], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test05() {
+		let mut v = json!({
+			"a":1
+		});
+		retain_initialized_fields(&mut v, &[], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test06() {
+		let mut v = json!({
+			"a": {
+				"b":1,
+				"c":2
+			}
+		});
+		retain_initialized_fields(&mut v, &[], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test07() {
+		let mut v = json!({
+			"a": {
+				"b":1,
+				"c":2
+			}
+		});
+		retain_initialized_fields(&mut v, &[InitializedField::full("a.b")], String::default());
+		assert_eq!(Value::Object(Default::default()), v);
+	}
+
+	#[test]
+	fn test08() {
+		let mut v = json!({
+			"a": {
+				"b":1,
+				"c":2
+			}
+		});
+		let e = json!({
+			"a": {
+				"b":1,
+			}
+		});
+		retain_initialized_fields(
+			&mut v,
+			&[InitializedField::partial("a"), InitializedField::full("a.b")],
+			String::default(),
+		);
+		assert_eq!(e, v);
+	}
+
+	#[test]
+	fn test09() {
+		let mut v = json!({
+			"a": {
+				"b":1,
+				"c":2
+			}
+		});
+		let e = json!({
+			"a": {
+				"b":1,
+				"c":2,
+			}
+		});
+		retain_initialized_fields(&mut v, &[InitializedField::full("a")], String::default());
+		assert_eq!(e, v);
+	}
+}
diff --git a/substrate/frame/support/src/lib.rs b/substrate/frame/support/src/lib.rs
index cc805d724857..2e7ea0a07d7d 100644
--- a/substrate/frame/support/src/lib.rs
+++ b/substrate/frame/support/src/lib.rs
@@ -53,6 +53,7 @@ pub mod __private {
 	pub use paste;
 	pub use scale_info;
 	pub use serde;
+	pub use serde_json;
 	pub use sp_core::{Get, OpaqueMetadata, Void};
 	pub use sp_crypto_hashing_proc_macro;
 	pub use sp_inherents;
@@ -2588,9 +2589,12 @@ sp_core::generate_feature_enabled_macro!(try_runtime_enabled, feature = "try-run
 sp_core::generate_feature_enabled_macro!(try_runtime_or_std_enabled, any(feature = "try-runtime", feature = "std"), $);
 sp_core::generate_feature_enabled_macro!(try_runtime_and_std_not_enabled, all(not(feature = "try-runtime"), not(feature = "std")), $);
 
-// Helper for implementing GenesisBuilder runtime API
+/// Helper for implementing GenesisBuilder runtime API
 pub mod genesis_builder_helper;
 
+/// Helper for generating the `RuntimeGenesisConfig` instance for presets.
+pub mod generate_genesis_config;
+
 #[cfg(test)]
 mod test {
 	// use super::*;