diff --git a/Cargo.lock b/Cargo.lock index cfa3fcef..333ebb77 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3627,15 +3627,6 @@ dependencies = [ "slab", ] -[[package]] -name = "fuzzy-matcher" -version = "0.3.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94" -dependencies = [ - "thread_local", -] - [[package]] name = "fxhash" version = "0.2.1" @@ -8084,7 +8075,6 @@ dependencies = [ "cumulus-primitives-proof-size-hostfunction 0.10.0", "duct", "frame-benchmarking-cli", - "fuzzy-matcher", "glob", "indexmap 2.7.0", "pop-common", diff --git a/Cargo.toml b/Cargo.toml index 5a6339f3..a3452484 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,7 +76,6 @@ git2_credentials = "0.13.0" # benchmarking cumulus-primitives-proof-size-hostfunction = "0.10.0" frame-benchmarking-cli = "46.0.0" -fuzzy-matcher = "0.3.7" sc-chain-spec = "41.0.0" sp-runtime = "40.0.1" sp-statement-store = "15.0.0" diff --git a/crates/pop-cli/src/commands/bench/pallet.rs b/crates/pop-cli/src/commands/bench/pallet.rs index de835c75..1b9596da 100644 --- a/crates/pop-cli/src/commands/bench/pallet.rs +++ b/crates/pop-cli/src/commands/bench/pallet.rs @@ -16,16 +16,14 @@ use clap::Args; use cliclack::spinner; use pop_common::Profile; use pop_parachains::{ - generate_benchmarks, get_preset_names, load_pallet_extrinsics, search_for_extrinsics, - search_for_pallets, GenesisBuilderPolicy, PalletExtrinsicsRegistry, GENESIS_BUILDER_DEV_PRESET, + generate_benchmarks, get_preset_names, load_pallet_extrinsics, GenesisBuilderPolicy, + PalletExtrinsicsRegistry, GENESIS_BUILDER_DEV_PRESET, }; use std::{collections::HashMap, path::PathBuf}; use strum::{EnumMessage, IntoEnumIterator}; use strum_macros::{EnumIter, EnumMessage as EnumMessageDerive}; const ALL_SELECTED: &str = "*"; -const MAX_EXTRINSIC_LIMIT: usize = 15; -const MAX_PALLET_LIMIT: usize = 20; #[derive(Args)] pub(crate) struct BenchmarkPallet { @@ -279,7 +277,7 @@ impl BenchmarkPallet { }; } - // No pallet provided, prompts user to select the pallets fetched from runtime. + // No pallet provided, prompts user to select the pallet fetched from runtime. if self.pallet.is_none() { self.update_pallets(cli, &mut registry).await?; } @@ -804,42 +802,34 @@ fn guide_user_to_select_pallet( excluded_pallets: &[String], cli: &mut impl cli::traits::Cli, ) -> anyhow::Result { - // Prompt for pallet search input. - let input = cli - .input(r#"🔎 Search for pallets by name ("*" to select all)"#) - .placeholder(ALL_SELECTED) - .default_input(ALL_SELECTED) - .required(false) - .interact()?; - - if input.trim() == ALL_SELECTED { + let pallets = pallets(registry, excluded_pallets); + if pallets.is_empty() { + return Err(anyhow::anyhow!("No pallets found for the runtime")); + } + + if cli + .confirm("Would you like to benchmark all pallets?") + .initial_value(true) + .interact()? + { return Ok(ALL_SELECTED.to_string()); } - // Prompt user to select pallets. - let pallets = search_for_pallets(registry, excluded_pallets, &input, MAX_PALLET_LIMIT); - let mut prompt = cli.select("Select a pallet to benchmark:"); + let mut prompt = cli.select(r#"🔎 Search for a pallet to benchmark"#).filter_mode(); for pallet in pallets { prompt = prompt.item(pallet.clone(), &pallet, ""); } - Ok(prompt.interact()?) + Ok(prompt.interact()?.to_string()) } fn guide_user_to_exclude_pallets( registry: &PalletExtrinsicsRegistry, cli: &mut impl cli::traits::Cli, ) -> anyhow::Result> { - // Prompt for pallet search input. - let input = cli - .input(r#"🔎 Search for pallets by name to exclude"#) - .placeholder("balances") - .required(false) - .interact()?; - - // Prompt user to select pallets. - let pallets = search_for_pallets(registry, &[], &input, MAX_PALLET_LIMIT); - let mut prompt = cli.multiselect("Exclude pallets from benchmarking:").required(false); - for pallet in pallets { + let mut prompt = cli + .multiselect(r#"🔎 Search for pallets to exclude (Press ENTER to skip)"#) + .required(false); + for pallet in pallets(registry, &[]) { prompt = prompt.item(pallet.clone(), &pallet, ""); } Ok(prompt.interact()?) @@ -850,21 +840,23 @@ fn guide_user_to_select_extrinsics( registry: &PalletExtrinsicsRegistry, cli: &mut impl cli::traits::Cli, ) -> anyhow::Result { - // Prompt for extrinsic search input. - let input = cli - .input(r#"🔎 Search for extrinsics by name ("*" to select all)"#) - .placeholder(ALL_SELECTED) - .default_input(ALL_SELECTED) - .required(false) - .interact()?; - - if input.trim() == ALL_SELECTED { + let extrinsics = extrinsics(registry, pallet); + if extrinsics.is_empty() { + return Err(anyhow::anyhow!("No extrinsics found for the pallet")); + } + + if cli + .confirm(format!(r#"Would you like to benchmark all extrinsics of "{}"?"#, pallet)) + .initial_value(true) + .interact()? + { return Ok(ALL_SELECTED.to_string()); } - // Prompt user to select extrinsics. - let extrinsics = search_for_extrinsics(registry, pallet, &input, MAX_EXTRINSIC_LIMIT); - let mut prompt = cli.multiselect("Select the extrinsics:").required(true); + let mut prompt = cli + .multiselect(r#"🔎 Search for extrinsics to benchmark"#) + .filter_mode() + .required(true); for extrinsic in extrinsics { prompt = prompt.item(extrinsic.clone(), &extrinsic, ""); } @@ -908,6 +900,18 @@ fn parse_pallet_name(pallet: &str) -> std::result::Result { Ok(pallet.replace("-", "_")) } +fn pallets(registry: &PalletExtrinsicsRegistry, excluded_pallets: &[String]) -> Vec { + registry + .keys() + .filter(|s| !excluded_pallets.contains(&s.to_string())) + .map(String::from) + .collect() +} + +fn extrinsics(registry: &PalletExtrinsicsRegistry, pallet: &str) -> Vec { + registry.get(pallet).cloned().unwrap_or_default() +} + #[cfg(test)] mod tests { use super::*; @@ -925,9 +929,6 @@ mod tests { let cwd = current_dir().unwrap_or(PathBuf::from("./")); let runtime_path = get_mock_runtime(true); - let binary_path = - source_omni_bencher_binary(&mut MockCli::new(), &crate::cache()?, true).await?; - let registry = load_pallet_extrinsics(&runtime_path, binary_path.as_path()).await?; let output_path = temp_dir.path().join("weights.rs"); cli = expect_pallet_benchmarking_intro(cli); @@ -939,29 +940,20 @@ mod tests { .expect_input( "Please provide the path to the runtime or parachain project.", runtime_path.to_str().unwrap().to_string(), - ); - cli = expect_select_pallet(cli, ®istry, &"pallet_timestamp", &[], MAX_PALLET_LIMIT, 0); - cli = expect_select_extrinsics( - cli, - ®istry, - "pallet_timestamp", - "set", - MAX_EXTRINSIC_LIMIT, - ); - cli = cli + ) .expect_warning("NOTE: this may take some time...") - .expect_info("Benchmarking extrinsic weights of selected pallets..."); - - // Verify the output of generated weight file. - cli = cli.expect_input( - "Provide the output file path for benchmark results (optional).", - output_path.to_str().unwrap().to_string(), - ); + .expect_info("Benchmarking extrinsic weights of selected pallets...") + .expect_input( + "Provide the output file path for benchmark results (optional).", + output_path.to_str().unwrap().to_string(), + ); let mut cmd = BenchmarkPallet { skip_menu: true, skip_confirm: false, genesis_builder: Some(GenesisBuilderPolicy::None), + pallet: Some("pallet_timestamp".to_string()), + extrinsic: Some(ALL_SELECTED.to_string()), ..Default::default() }; cmd.execute(&mut cli).await?; @@ -1031,27 +1023,47 @@ mod tests { } #[tokio::test] - async fn guide_user_to_select_pallets_works() -> anyhow::Result<()> { + async fn guide_user_to_select_pallet_works() -> anyhow::Result<()> { let runtime_path = get_mock_runtime(true); let binary_path = source_omni_bencher_binary(&mut MockCli::new(), &crate::cache()?, true).await?; let registry = load_pallet_extrinsics(&runtime_path, binary_path.as_path()).await?; + let pallet_items: Vec<(String, String)> = pallets(®istry, &[]) + .into_iter() + .map(|pallet| (pallet, Default::default())) + .collect(); + let prompt = "Would you like to benchmark all pallets?"; // Select all pallets. - let mut cli = - expect_select_pallet(MockCli::new(), ®istry, ALL_SELECTED, &[], MAX_PALLET_LIMIT, 0); - let input = guide_user_to_select_pallet(®istry, &[], &mut cli)?; - assert_eq!(input, ALL_SELECTED.to_string()); + let mut cli = MockCli::new().expect_confirm(prompt, true); + assert_eq!( + guide_user_to_select_pallet(®istry, &[], &mut cli)?, + ALL_SELECTED.to_string() + ); cli.verify()?; - // Search for pallets. - let input = "pallet_timestamp"; - let mut cli = - expect_select_pallet(MockCli::new(), ®istry, &input, &[], MAX_PALLET_LIMIT, 0); + // Not exclude pallets. + cli = MockCli::new().expect_confirm(prompt, false).expect_select( + r#"🔎 Search for a pallet to benchmark"#, + None, + true, + Some(pallet_items.clone()), + 0, + Some(true), + ); + guide_user_to_select_pallet(®istry, &[], &mut cli)?; + cli.verify()?; - let selected = guide_user_to_select_pallet(®istry, &vec![], &mut cli)?; - assert_eq!(selected, input.to_string()); - // TODO: Excluded pallets. + // Exclude pallets + cli = MockCli::new().expect_confirm(prompt, false).expect_select( + r#"🔎 Search for a pallet to benchmark"#, + None, + true, + Some(pallet_items.into_iter().filter(|(p, _)| p != "pallet_timestamp").collect()), + 0, + Some(true), + ); + guide_user_to_select_pallet(®istry, &["pallet_timestamp".to_string()], &mut cli)?; cli.verify() } @@ -1061,23 +1073,17 @@ mod tests { let runtime_path = get_mock_runtime(true); let binary_path = source_omni_bencher_binary(&mut cli, &crate::cache()?, true).await?; let registry = load_pallet_extrinsics(&runtime_path, binary_path.as_path()).await?; - - let pallet_items = search_for_pallets(®istry, &[], &"", MAX_PALLET_LIMIT) + let pallet_items = pallets(®istry, &[]) .into_iter() .map(|pallet| (pallet, Default::default())) - .take(MAX_PALLET_LIMIT) .collect(); - cli = MockCli::new() - .expect_input( - r#"🔎 Search for pallets by name to exclude"#, - "pallet_timestamp".to_string(), - ) - .expect_multiselect::( - "Exclude pallets from benchmarking:", - Some(false), - true, - Some(pallet_items), - ); + cli = MockCli::new().expect_multiselect::( + r#"🔎 Search for pallets to exclude (Press ENTER to skip)"#, + Some(false), + true, + Some(pallet_items), + Some(true), + ); guide_user_to_exclude_pallets(®istry, &mut cli)?; cli.verify() } @@ -1088,30 +1094,33 @@ mod tests { let runtime_path = get_mock_runtime(true); let binary_path = source_omni_bencher_binary(&mut cli, &crate::cache()?, true).await?; let registry = load_pallet_extrinsics(&runtime_path, binary_path.as_path()).await?; + let extrinsic_items = extrinsics(®istry, "pallet_timestamp") + .into_iter() + .map(|pallet| (pallet, Default::default())) + .collect(); - // Select all extrinsics. - let mut cli = expect_select_extrinsics( - MockCli::new(), - ®istry, - "pallet_timestamp", - ALL_SELECTED, - MAX_EXTRINSIC_LIMIT, + let mut cli = MockCli::new().expect_confirm( + r#"Would you like to benchmark all extrinsics of "pallet_timestamp"?"#, + true, ); - let input = - guide_user_to_select_extrinsics(&"pallet_timestamp".to_string(), ®istry, &mut cli)?; - assert_eq!(input, ALL_SELECTED.to_string()); - cli.verify()?; - - // Search for extrinsics. - let mut cli = expect_select_extrinsics( - MockCli::new(), - ®istry, - "pallet_timestamp", - "on_finalize", - MAX_EXTRINSIC_LIMIT, + assert_eq!( + guide_user_to_select_extrinsics(&"pallet_timestamp".to_string(), ®istry, &mut cli)?, + ALL_SELECTED.to_string() ); + + cli = MockCli::new() + .expect_confirm( + r#"Would you like to benchmark all extrinsics of "pallet_timestamp"?"#, + false, + ) + .expect_multiselect::( + r#"🔎 Search for extrinsics to benchmark"#, + Some(true), + true, + Some(extrinsic_items), + Some(true), + ); guide_user_to_select_extrinsics(&"pallet_timestamp".to_string(), ®istry, &mut cli)?; - assert_eq!(input, ALL_SELECTED.to_string()); cli.verify() } @@ -1296,57 +1305,4 @@ mod tests { "NOTE: the `pop bench pallet` is not yet battle tested - double check the results.", ) } - - fn expect_select_pallet( - cli: MockCli, - registry: &PalletExtrinsicsRegistry, - input: &str, - excluded_pallets: &[String], - limit: usize, - item: usize, - ) -> MockCli { - let pallet_items = search_for_pallets(®istry, excluded_pallets, input, limit) - .into_iter() - .map(|pallet| (pallet, Default::default())) - .collect(); - - let prompt = r#"🔎 Search for pallets by name ("*" to select all)"#; - - if is_selected_all(&input.to_string()) { - cli.expect_input(prompt, input.to_string()) - } else { - cli.expect_input(prompt, input.to_string()).expect_select( - "Select a pallet to benchmark:", - Some(false), - true, - Some(pallet_items), - item, - ) - } - } - - fn expect_select_extrinsics( - cli: MockCli, - registry: &PalletExtrinsicsRegistry, - pallet: &str, - input: &str, - limit: usize, - ) -> MockCli { - let extrinsic_items = search_for_extrinsics(®istry, &pallet.to_string(), input, limit) - .into_iter() - .map(|pallet| (pallet, Default::default())) - .collect(); - let prompt = r#"🔎 Search for extrinsics by name ("*" to select all)"#; - - if is_selected_all(&input.to_string()) { - cli.expect_input(prompt, input.to_string()) - } else { - cli.expect_input(prompt, input.to_string()).expect_multiselect::( - "Select the extrinsics:", - Some(true), - true, - Some(extrinsic_items), - ) - } - } } diff --git a/crates/pop-cli/src/common/bench.rs b/crates/pop-cli/src/common/bench.rs index e3dd4ca2..1f74927e 100644 --- a/crates/pop-cli/src/common/bench.rs +++ b/crates/pop-cli/src/common/bench.rs @@ -345,7 +345,14 @@ mod tests { // Found runtimes in the specified runtime path. let mut cli = MockCli::new(); - cli = cli.expect_select("Select the runtime:", Some(true), true, Some(runtime_items), 0); + cli = cli.expect_select( + "Select the runtime:", + Some(true), + true, + Some(runtime_items), + 0, + None, + ); fs::create_dir(&runtime_path)?; for runtime in runtimes { @@ -381,7 +388,14 @@ mod tests { let runtimes = ["runtime-1", "runtime-2", "runtime-3"]; let runtime_items = runtimes.map(|runtime| (runtime.to_string(), "".to_string())).to_vec(); cli = MockCli::new(); - cli = cli.expect_select("Select the runtime:", Some(true), true, Some(runtime_items), 0); + cli = cli.expect_select( + "Select the runtime:", + Some(true), + true, + Some(runtime_items), + 0, + None, + ); for runtime in runtimes { cmd("cargo", ["new", runtime, "--bin"]).dir(&runtime_path).run()?; } @@ -429,6 +443,7 @@ mod tests { true, Some(policies), item, + None, ) } @@ -444,6 +459,7 @@ mod tests { true, Some(preset_names), item, + None, ) } } diff --git a/crates/pop-parachains/Cargo.toml b/crates/pop-parachains/Cargo.toml index 252b7d4a..bfcf4379 100644 --- a/crates/pop-parachains/Cargo.toml +++ b/crates/pop-parachains/Cargo.toml @@ -37,7 +37,6 @@ zombienet-sdk.workspace = true # Benchmarking cumulus-primitives-proof-size-hostfunction.workspace = true frame-benchmarking-cli.workspace = true -fuzzy-matcher = "0.3.7" sc-chain-spec.workspace = true sp-runtime.workspace = true sp-statement-store.workspace = true diff --git a/crates/pop-parachains/src/bench.rs b/crates/pop-parachains/src/bench.rs deleted file mode 100644 index bf9aeb61..00000000 --- a/crates/pop-parachains/src/bench.rs +++ /dev/null @@ -1,99 +0,0 @@ -use std::{ - fs, - path::{Path, PathBuf}, -}; - -use anyhow::Result; -use clap::Parser; -use frame_benchmarking_cli::PalletCmd; -use sc_chain_spec::GenesisConfigBuilderRuntimeCaller; -use sp_runtime::traits::BlakeTwo256; - -type HostFunctions = ( - sp_statement_store::runtime_api::HostFunctions, - cumulus_primitives_proof_size_hostfunction::storage_proof_size::HostFunctions, -); - -/// Get genesis builder preset names of the runtime. -/// -/// # Arguments -/// * `binary_path` - Path to the runtime WASM binary. -pub fn get_preset_names(binary_path: &PathBuf) -> anyhow::Result> { - let binary = fs::read(binary_path).expect("No runtime binary found"); - let genesis_config_builder = GenesisConfigBuilderRuntimeCaller::::new(&binary); - genesis_config_builder.preset_names().map_err(|e| anyhow::anyhow!(e)) -} - -/// Get the runtime folder path and throws error if not exist. -/// -/// # Arguments -/// * `parent` - Parent path that contains the runtime folder. -pub fn get_runtime_path(parent: &Path) -> anyhow::Result { - ["runtime", "runtimes"] - .iter() - .map(|f| parent.join(f)) - .find(|path| path.exists()) - .ok_or_else(|| anyhow::anyhow!("No runtime found.")) -} - -/// Parse the pallet command from string value of genesis policy builder. -/// -/// # Arguments -/// * `policy` - Genesis builder policy ( none | spec | runtime ). -pub fn parse_genesis_builder_policy(policy: &str) -> anyhow::Result { - PalletCmd::try_parse_from([ - "", - "--list", - "--runtime", - "dummy-runtime", // For parsing purpose. - "--genesis-builder", - policy, - ]) - .map_err(|e| { - anyhow::anyhow!(format!(r#"Invalid genesis builder option {policy}: {}"#, e.to_string())) - }) -} - -/// Run command for pallet benchmarking. -/// -/// # Arguments -/// * `cmd` - Command to benchmark the FRAME Pallets. -pub fn run_pallet_benchmarking(cmd: &PalletCmd) -> Result<()> { - cmd.run_with_spec::(None) - .map_err(|e| anyhow::anyhow!(format!("Failed to run benchmarking: {}", e.to_string()))) -} - -#[cfg(test)] -mod tests { - use super::*; - use tempfile::tempdir; - - #[test] - fn get_preset_names_works() -> anyhow::Result<()> { - let runtime_path = std::env::current_dir() - .unwrap() - .join("../../tests/runtimes/base_parachain_benchmark.wasm") - .canonicalize()?; - assert_eq!(get_preset_names(&runtime_path)?, vec!["development", "local_testnet"]); - Ok(()) - } - - #[test] - fn get_runtime_path_works() -> anyhow::Result<()> { - let temp_dir = tempdir()?; - for name in ["runtime", "runtimes"] { - let path = temp_dir.path(); - fs::create_dir(&path.join(name))?; - get_runtime_path(&path)?; - } - Ok(()) - } - - #[test] - fn parse_genesis_builder_policy_works() -> anyhow::Result<()> { - for policy in ["none", "runtime"] { - parse_genesis_builder_policy(policy)?; - } - Ok(()) - } -} diff --git a/crates/pop-parachains/src/bench/mod.rs b/crates/pop-parachains/src/bench/mod.rs index 48fc5699..dbfb0232 100644 --- a/crates/pop-parachains/src/bench/mod.rs +++ b/crates/pop-parachains/src/bench/mod.rs @@ -2,7 +2,6 @@ use clap::Parser; use frame_benchmarking_cli::PalletCmd; -use fuzzy_matcher::{skim::SkimMatcherV2, FuzzyMatcher}; use sc_chain_spec::GenesisConfigBuilderRuntimeCaller; use sp_runtime::traits::BlakeTwo256; use std::{ @@ -174,66 +173,6 @@ pub async fn run_benchmarking_with_binary( Ok(child) } -/// Performs a fuzzy search for pallets that match the provided input. -/// -/// # Arguments -/// * `registry` - A mapping of pallets and their extrinsics. -/// * `excluded_pallets` - Pallets that are excluded from the search results. -/// * `input` - The search input used to match pallets. -/// * `limit` - Maximum number of pallets returned from search. -pub fn search_for_pallets( - registry: &PalletExtrinsicsRegistry, - excluded_pallets: &[String], - input: &str, - limit: usize, -) -> Vec { - let matcher = SkimMatcherV2::default(); - let pallets = registry.keys(); - - if input.is_empty() { - return pallets.map(String::from).take(limit).collect(); - } - let pallets: Vec<&str> = pallets - .filter(|s| !excluded_pallets.contains(&s.to_string())) - .map(String::as_str) - .collect(); - let mut output: Vec<(String, i64)> = pallets - .into_iter() - .map(|v| (v.to_string(), matcher.fuzzy_match(v, input).unwrap_or_default())) - .collect(); - // Sort pallets by score. - output.sort_by(|a, b| b.1.cmp(&a.1)); - output.into_iter().map(|(name, _)| name).take(limit).collect::>() -} - -/// Performs a fuzzy search for extrinsics that match the provided input. -/// -/// # Arguments -/// * `registry` - A mapping of pallets and their extrinsics. -/// * `pallet` - Pallet to find the extrinsics. -/// * `input` - The search input used to match extrinsics. -/// * `limit` - The maximum number of results to return. -pub fn search_for_extrinsics( - registry: &PalletExtrinsicsRegistry, - pallet: &String, - input: &str, - limit: usize, -) -> Vec { - let matcher = SkimMatcherV2::default(); - let extrinsics = registry.get(pallet).cloned().unwrap_or_default(); - - if input.is_empty() { - return extrinsics.into_iter().take(limit).collect(); - } - let mut output: Vec<(String, i64)> = extrinsics - .into_iter() - .map(|v| (v.clone(), matcher.fuzzy_match(&v, input).unwrap_or_default())) - .collect(); - // Sort extrinsics by score. - output.sort_by(|a, b| b.1.cmp(&a.1)); - output.into_iter().map(|(name, _)| name).take(limit).collect::>() -} - #[cfg(test)] mod tests { use super::*; @@ -289,43 +228,6 @@ mod tests { Ok(()) } - #[test] - fn search_pallets_works() { - let registry = get_mock_registry(); - [ - ("balances", "pallet_balances"), - ("timestamp", "pallet_timestamp"), - ("system", "frame_system"), - ] - .iter() - .for_each(|(input, pallet)| { - let pallets = search_for_pallets(®istry, &[], input, 5); - assert_eq!(pallets.first(), Some(&pallet.to_string())); - assert_eq!(pallets.len(), 3); - }); - - assert_ne!( - search_for_pallets(®istry, &["pallet_timestamp".to_string()], "timestamp", 5) - .first(), - Some(&"pallet_timestamp".to_string()) - ); - } - - #[test] - fn search_extrinsics_works() { - let registry = get_mock_registry(); - // Extrinsics are sorted alphabetically if there are no matches. - assert_eq!( - search_for_extrinsics(®istry, &"pallet_timestamp".to_string(), "", 5), - vec!["on_finalize".to_string(), "set".to_string()] - ); - // Sort by score if there are matches. - assert_eq!( - search_for_extrinsics(®istry, &"pallet_timestamp".to_string(), "set", 5), - vec!["set".to_string(), "on_finalize".to_string()] - ); - } - fn get_mock_runtime_path(with_runtime_benchmarks: bool) -> PathBuf { let binary_path = format!( "../../tests/runtimes/{}.wasm", @@ -333,19 +235,4 @@ mod tests { ); std::env::current_dir().unwrap().join(binary_path).canonicalize().unwrap() } - - fn get_mock_registry() -> PalletExtrinsicsRegistry { - PalletExtrinsicsRegistry::from([ - ( - "pallet_balances".to_string(), - vec![ - "transfer".to_string(), - "force_transfer".to_string(), - "set_balance".to_string(), - ], - ), - ("pallet_timestamp".to_string(), vec!["on_finalize".to_string(), "set".to_string()]), - ("frame_system".to_string(), vec!["set_code".to_string(), "remark".to_string()]), - ]) - } } diff --git a/crates/pop-parachains/src/lib.rs b/crates/pop-parachains/src/lib.rs index 4522b345..e28de0a2 100644 --- a/crates/pop-parachains/src/lib.rs +++ b/crates/pop-parachains/src/lib.rs @@ -16,8 +16,7 @@ mod utils; pub use bench::{ binary::*, generate_benchmarks, get_preset_names, get_runtime_path, load_pallet_extrinsics, - search_for_extrinsics, search_for_pallets, GenesisBuilderPolicy, PalletExtrinsicsRegistry, - GENESIS_BUILDER_DEV_PRESET, + GenesisBuilderPolicy, PalletExtrinsicsRegistry, GENESIS_BUILDER_DEV_PRESET, }; pub use build::{ binary_path, build_parachain, build_project, export_wasm_file, generate_genesis_state_file,