Add rococo runtime fuzzer

templates/Cargo.toml

@@ -7,13 +7,15 @@ publish = false
 [workspace]
 resolver = "2"
 members = [
+    "rococo",
     "kitchensink",
     "solochain",
 ]
 
 [workspace.dependencies]
 ziggy = {version = "1.5.2", default-features = false}
 
+rococo-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 solochain-template-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 kitchensink-runtime = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 
@@ -33,6 +35,10 @@ sp-consensus-aura = { git = "https://github.com/paritytech/polkadot-sdk.git", ta
 sp-consensus-babe = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 sp-consensus-beefy = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 sp-authority-discovery = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
+sp-application-crypto = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
+sp-tracing = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
+
+polkadot-primitives = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 
 pallet-timestamp = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }
 pallet-balances = { git = "https://github.com/paritytech/polkadot-sdk.git", tag = "polkadot-stable2603", default-features = false }

templates/rococo/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "rococo-fuzzer"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+ziggy = { workspace = true }
+
+rococo-runtime = { workspace = true }
+
+codec = { workspace = true }
+
+node-primitives = { workspace = true }
+
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+frame-metadata = { workspace = true }
+
+scale-info = { workspace = true }
+
+sp-runtime = { workspace = true }
+sp-state-machine = { workspace = true }
+sp-consensus-babe = { workspace = true }
+sp-consensus-beefy = { workspace = true }
+sp-authority-discovery = { workspace = true }
+sp-tracing = { workspace = true }
+sp-application-crypto = { workspace = true }
+sp-core = { workspace = true }
+
+polkadot-primitives = { workspace = true }
+
+pallet-timestamp = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-grandpa = { workspace = true }
+pallet-utility = { workspace = true }
+pallet-proxy = { workspace = true }
+pallet-multisig = { workspace = true }
+
+[features]
+default = ["std", "try-runtime"]
+fuzzing = []
+std = [
+    "rococo-runtime/std",
+	"sp-runtime/std",
+	"frame-support/std",
+	"pallet-timestamp/std",
+	"sp-consensus-babe/std",
+]
+try-runtime = [
+    "rococo-runtime/try-runtime",
+	"frame-support/try-runtime",
+	"pallet-timestamp/try-runtime",
+]

templates/rococo/allowlist.txt

@@ -0,0 +1 @@
+*pallet_*

templates/rococo/src/bin/seedgen.rs

@@ -0,0 +1,127 @@
+#![warn(clippy::pedantic)]
+use codec::{Decode, Encode};
+use frame_metadata::{RuntimeMetadata, RuntimeMetadataPrefixed};
+use frame_support::traits::GetCallMetadata;
+use rococo_runtime::{Runtime, RuntimeCall};
+use scale_info::TypeDef;
+use sp_state_machine::BasicExternalities;
+use std::{collections::BTreeMap, fs, path::Path};
+
+fn main() {
+    let seeds = build_seeds();
+
+    let out_dir = Path::new("seedgen");
+    fs::create_dir_all(out_dir).expect("create seedgen dir");
+    for (name, seed) in &seeds {
+        let path = out_dir.join(format!("{name}.seed"));
+        fs::write(&path, seed).expect("write seed file");
+    }
+
+    println!("wrote {} seeds to {}", seeds.len(), out_dir.display());
+}
+
+fn build_seeds() -> Vec<(String, Vec<u8>)> {
+    let mut seeds: Vec<(String, Vec<u8>)> = Vec::new();
+
+    let metadata = load_metadata_v14();
+    let call_map = build_call_map(&metadata);
+    for (pallet, calls) in call_map {
+        let expected =
+            pallet_call_variant_count(&metadata, pallet.as_str()).expect("pallet call count");
+        let actual = calls.len();
+        println!("created {actual}/{expected} seeds for {pallet}");
+        if actual != expected {
+            println!(
+                "  skipped {} calls in {pallet} (unencodable with only zeroes)",
+                expected - actual
+            );
+        }
+
+        for call in calls {
+            let meta = call.get_call_metadata();
+            let name = format!(
+                "{}_{}",
+                meta.pallet_name.to_ascii_lowercase(),
+                meta.function_name
+            );
+            seeds.push((name, (0u8, 0u8, call).encode()));
+        }
+    }
+
+    seeds
+}
+
+fn build_call_map(
+    metadata: &frame_metadata::v14::RuntimeMetadataV14,
+) -> BTreeMap<String, Vec<RuntimeCall>> {
+    let mut map: BTreeMap<String, Vec<RuntimeCall>> = BTreeMap::new();
+    for pallet in &metadata.pallets {
+        let calls = pallet.calls.as_ref();
+        if calls.is_none() {
+            continue;
+        }
+        let calls = calls.expect("checked");
+        let mut runtime_calls = Vec::new();
+        let call_def = metadata
+            .types
+            .resolve(calls.ty.id)
+            .expect("resolve pallet call type");
+        let TypeDef::Variant(variants) = &call_def.type_def else {
+            continue;
+        };
+        for variant in &variants.variants {
+            if variant.name == "__Ignore" {
+                continue;
+            }
+            if let Some(call) = runtime_call_from_metadata(metadata, pallet, variant) {
+                runtime_calls.push(call);
+            }
+        }
+        map.insert(pallet.name.clone(), runtime_calls);
+    }
+    map
+}
+
+fn load_metadata_v14() -> frame_metadata::v14::RuntimeMetadataV14 {
+    let bytes: Vec<u8> = BasicExternalities::default().execute_with(|| Runtime::metadata().into());
+    let metadata = RuntimeMetadataPrefixed::decode(&mut &bytes[..]).expect("decode metadata");
+    match metadata.1 {
+        RuntimeMetadata::V14(m) => m,
+        _ => panic!("unsupported metadata version"),
+    }
+}
+
+fn runtime_call_from_metadata(
+    metadata: &frame_metadata::v14::RuntimeMetadataV14,
+    pallet: &frame_metadata::v14::PalletMetadata<scale_info::form::PortableForm>,
+    variant: &scale_info::Variant<scale_info::form::PortableForm>,
+) -> Option<RuntimeCall> {
+    let calls = pallet.calls.as_ref()?;
+    let call_def = metadata.types.resolve(calls.ty.id)?;
+    let TypeDef::Variant(_) = &call_def.type_def else {
+        return None;
+    };
+    let mut bytes = pallet.index.encode();
+    bytes.extend_from_slice(&variant.index.encode());
+    bytes.extend_from_slice(&[0u8; 1024]);
+    RuntimeCall::decode(&mut &bytes[..]).ok()
+}
+
+fn pallet_call_variant_count(
+    metadata: &frame_metadata::v14::RuntimeMetadataV14,
+    pallet_name: &str,
+) -> Option<usize> {
+    let pallet = metadata.pallets.iter().find(|p| p.name == pallet_name)?;
+    let calls = pallet.calls.as_ref()?;
+    let ty = metadata.types.resolve(calls.ty.id)?;
+    let TypeDef::Variant(variants) = &ty.type_def else {
+        return None;
+    };
+    Some(
+        variants
+            .variants
+            .iter()
+            .filter(|variant| variant.name != "__Ignore")
+            .count(),
+    )
+}