refactor: remove psp example and improve pop new contract devex (#700)

* refactor: remove psp example and improve pop new contract devex

* fix: CI

* fmt

* refactor: minimise changes

* fix: remove ContractType

* fix: remove agents file

* fix: ci

* fix: test

Author: Daanvdplas

crates/pop-cli/src/commands/new/contract.rs

@@ -14,27 +14,20 @@ use clap::{
 	builder::{PossibleValue, PossibleValuesParser, TypedValueParser},
 };
 use console::style;
-use pop_common::{
-	enum_variants, get_project_name_from_path,
-	templates::{Template, Type},
+use pop_common::{enum_variants, get_project_name_from_path, templates::Template};
+use pop_contracts::{Contract, create_smart_contract, is_valid_contract_name};
+use std::{
+	fs,
+	path::{Path, PathBuf},
+	str::FromStr,
 };
-use pop_contracts::{Contract, ContractType, create_smart_contract, is_valid_contract_name};
-use std::{fs, path::Path, str::FromStr};
 use strum::VariantArray;
 
 #[derive(Args, Clone)]
 #[cfg_attr(test, derive(Default))]
 pub struct NewContractCommand {
 	/// The name of the contract.
 	pub(crate) name: Option<String>,
-	/// The type of contract.
-	#[arg(
-		default_value = ContractType::Examples.as_ref(),
-		short,
-		long,
-		value_parser = enum_variants!(ContractType)
-	)]
-	pub(crate) contract_type: Option<ContractType>,
 	/// The template to use.
 	#[arg(short, long, value_parser = enum_variants!(Contract))]
 	pub(crate) template: Option<Contract>,
@@ -44,17 +37,15 @@ impl NewContractCommand {
 	/// Executes the command.
 	pub(crate) async fn execute(self) -> Result<Contract> {
 		let mut cli = Cli;
-		// If the user doesn't provide a name, guide them in generating a contract.
-		let contract_config = if self.name.is_none() {
-			guide_user_to_generate_contract(&mut cli).await?
-		} else {
-			self.clone()
-		};
 
-		let path_project = &contract_config
-			.name
-			.clone()
-			.expect("name can not be none as fallback above is interactive input; qed");
+		let mut command = self;
+
+		// Prompt for missing fields interactively
+		if command.name.is_none() || command.template.is_none() {
+			command = guide_user_to_generate_contract(&mut cli, command).await?;
+		}
+
+		let path_project = command.name.as_ref().expect("name can not be none; qed");
 		let path = Path::new(path_project);
 		let name = get_project_name_from_path(path, "my_contract");
 
@@ -64,86 +55,50 @@ impl NewContractCommand {
 			return Ok(Contract::Standard);
 		}
 
-		let contract_type = &contract_config.contract_type.clone().unwrap_or_default();
-		let template = match &contract_config.template {
-			Some(template) => template.clone(),
-			None => contract_type.default_template().expect("contract types have defaults; qed."), /* Default contract type */
-		};
-
-		is_template_supported(contract_type, &template)?;
-		generate_contract_from_template(name, path, &template, &mut cli)?;
+		let template = command.template.unwrap_or_default();
+		let contract_path = generate_contract_from_template(name, path, &template, &mut cli)?;
 
 		// If the contract is part of a workspace, add it to that workspace
 		if let Some(workspace_toml) = rustilities::manifest::find_workspace_manifest(path) {
 			// Canonicalize paths before passing to rustilities to avoid strip_prefix errors
 			// This ensures paths are absolute and consistent, especially when using simple names
 			rustilities::manifest::add_crate_to_workspace(
 				&workspace_toml.canonicalize()?,
-				&path.canonicalize()?,
+				&contract_path.canonicalize()?,
 			)?;
 		}
 
 		Ok(template)
 	}
 }
 
-/// Determines whether the specified template is supported by the type.
-fn is_template_supported(contract_type: &ContractType, template: &Contract) -> Result<()> {
-	if !contract_type.provides(template) {
-		return Err(anyhow::anyhow!(format!(
-			"The contract type \"{:?}\" doesn't support the {:?} template.",
-			contract_type, template
-		)));
-	};
-	Ok(())
-}
-
-/// Guide the user to generate a contract from available templates.
+/// Guide the user to provide any missing fields for contract generation.
 async fn guide_user_to_generate_contract(
 	cli: &mut impl cli::traits::Cli,
+	mut command: NewContractCommand,
 ) -> Result<NewContractCommand> {
 	cli.intro("Generate a contract")?;
 
-	let contract_type = {
-		let mut contract_type_prompt = cli.select("Select a template type: ".to_string());
-		for (i, contract_type) in ContractType::types().iter().enumerate() {
-			if i == 0 {
-				contract_type_prompt = contract_type_prompt.initial_value(contract_type);
-			}
-			contract_type_prompt = contract_type_prompt.item(
-				contract_type,
-				contract_type.name(),
-				format!(
-					"{} {} available option(s)",
-					contract_type.description(),
-					contract_type.templates().len(),
-				),
-			);
-		}
-		contract_type_prompt.interact()?
-	};
-	let template = display_select_options(contract_type, cli)?;
+	if command.template.is_none() {
+		let template = display_select_options(cli)?;
+		command.template = Some(template);
+	}
 
-	// Prompt for location.
-	let name: String = cli
-		.input("Where should your project be created?")
-		.placeholder("./my_contract")
-		.default_input("./my_contract")
-		.interact()?;
+	if command.name.is_none() {
+		let name: String = cli
+			.input("Where should your project be created?")
+			.placeholder("./my_contract")
+			.default_input("./my_contract")
+			.interact()?;
+		command.name = Some(name);
+	}
 
-	Ok(NewContractCommand {
-		name: Some(name),
-		contract_type: Some(contract_type.clone()),
-		template: Some(template),
-	})
+	Ok(command)
 }
 
-fn display_select_options(
-	contract_type: &ContractType,
-	cli: &mut impl cli::traits::Cli,
-) -> Result<Contract> {
-	let mut prompt = cli.select("Select the contract:".to_string());
-	for (i, template) in contract_type.templates().into_iter().enumerate() {
+fn display_select_options(cli: &mut impl cli::traits::Cli) -> Result<Contract> {
+	let mut prompt = cli.select("Select a template:".to_string());
+	for (i, template) in Contract::templates().iter().enumerate() {
 		if i == 0 {
 			prompt = prompt.initial_value(template);
 		}
@@ -157,7 +112,7 @@ fn generate_contract_from_template(
 	path: &Path,
 	template: &Contract,
 	cli: &mut impl cli::traits::Cli,
-) -> anyhow::Result<()> {
+) -> anyhow::Result<PathBuf> {
 	cli.intro(format!("Generating \"{}\" using {}!", name, template.name(),))?;
 
 	let contract_path = check_destination_path(path, cli)?;
@@ -193,7 +148,7 @@ fn generate_contract_from_template(
 		"Need help? Learn more at {}\n",
 		style("https://learn.onpop.io").magenta().underlined()
 	))?;
-	Ok(())
+	Ok(contract_path)
 }
 
 #[cfg(test)]
@@ -204,21 +159,20 @@ mod tests {
 		Command::New,
 		cli::MockCli,
 		commands::new::{Command::Contract, NewArgs},
-		new::contract::{guide_user_to_generate_contract, is_template_supported},
 	};
 	use anyhow::Result;
 	use clap::Parser;
 	use console::style;
-	use pop_common::templates::{Template, Type};
-	use pop_contracts::{Contract as ContractTemplate, ContractType};
+	use pop_common::templates::Template;
+	use pop_contracts::Contract as ContractTemplate;
 	use strum::VariantArray;
 	use tempfile::tempdir;
 
 	#[tokio::test]
 	async fn test_new_contract_command_execute_with_defaults_executes() -> Result<()> {
 		let dir = tempdir()?;
 		let dir_path = format!("{}/test_contract", dir.path().display());
-		let cli = Cli::parse_from(["pop", "new", "contract", &dir_path]);
+		let cli = Cli::parse_from(["pop", "new", "contract", &dir_path, "--template", "standard"]);
 
 		let New(NewArgs { command: Some(Contract(command)) }) = cli.command else {
 			panic!("unable to parse command")
@@ -230,47 +184,27 @@ mod tests {
 
 	#[tokio::test]
 	async fn guide_user_to_generate_contract_works() -> anyhow::Result<()> {
-		let mut items_select_contract_type: Vec<(String, String)> = Vec::new();
-		for contract_type in ContractType::VARIANTS {
-			items_select_contract_type.push((
-				contract_type.name().to_string(),
-				format!(
-					"{} {} available option(s)",
-					contract_type.description(),
-					contract_type.templates().len(),
-				),
-			));
-		}
 		let mut items_select_contract: Vec<(String, String)> = Vec::new();
-		for contract_template in ContractType::Erc.templates() {
+		for contract_template in ContractTemplate::VARIANTS {
 			items_select_contract.push((
 				contract_template.name().to_string(),
 				contract_template.description().to_string(),
 			));
 		}
 		let mut cli = MockCli::new()
 			.expect_intro("Generate a contract")
-			.expect_input("Where should your project be created?", "./erc20".into())
-			.expect_select(
-				"Select a template type: ",
-				Some(false),
-				true,
-				Some(items_select_contract_type),
-				1, // "ERC",
-				None,
-			)
 			.expect_select(
-				"Select the contract:",
+				"Select a template:",
 				Some(false),
 				true,
 				Some(items_select_contract),
-				0, // "ERC20"
+				1, // "erc20"
 				None,
-			);
+			)
+			.expect_input("Where should your project be created?", "./erc20".into());
 
-		let user_input = guide_user_to_generate_contract(&mut cli).await?;
+		let user_input = guide_user_to_generate_contract(&mut cli, Default::default()).await?;
 		assert_eq!(user_input.name, Some("./erc20".to_string()));
-		assert_eq!(user_input.contract_type, Some(ContractType::Erc));
 		assert_eq!(user_input.template, Some(ContractTemplate::ERC20));
 
 		cli.verify()
@@ -307,25 +241,6 @@ mod tests {
 		cli.verify()
 	}
 
-	#[test]
-	fn is_template_supported_works() -> Result<()> {
-		is_template_supported(&ContractType::Erc, &ContractTemplate::ERC20)?;
-		is_template_supported(&ContractType::Erc, &ContractTemplate::ERC721)?;
-		assert!(
-			is_template_supported(&ContractType::Erc, &ContractTemplate::CrossContract).is_err()
-		);
-		assert!(is_template_supported(&ContractType::Erc, &ContractTemplate::PSP22).is_err());
-		is_template_supported(&ContractType::Examples, &ContractTemplate::Standard)?;
-		is_template_supported(&ContractType::Examples, &ContractTemplate::CrossContract)?;
-		assert!(is_template_supported(&ContractType::Examples, &ContractTemplate::ERC20).is_err());
-		assert!(is_template_supported(&ContractType::Examples, &ContractTemplate::PSP22).is_err());
-		is_template_supported(&ContractType::Psp, &ContractTemplate::PSP22)?;
-		is_template_supported(&ContractType::Psp, &ContractTemplate::PSP34)?;
-		assert!(is_template_supported(&ContractType::Psp, &ContractTemplate::ERC20).is_err());
-		assert!(is_template_supported(&ContractType::Psp, &ContractTemplate::Standard).is_err());
-		Ok(())
-	}
-
 	#[tokio::test]
 	async fn test_contract_in_workspace_with_simple_name() -> Result<()> {
 		// The bug occurs when you pass a simple name like "flipper" instead of "./flipper"
@@ -349,7 +264,12 @@ edition = "2024"
 		// User runs: pop new contract flipper -t standard
 		// They pass just "flipper", not "./flipper"
 		let cli = Cli::parse_from([
-			"pop", "new", "contract", "flipper", // Just the name, not a path like "./flipper"
+			"pop",
+			"new",
+			"contract",
+			"flipper",
+			"--template",
+			"standard", // Just the name, not a path like "./flipper"
 		]);
 		let New(NewArgs { command: Some(Contract(command)) }) = cli.command else {
 			panic!("unable to parse command")

crates/pop-cli/src/commands/new/mod.rs

@@ -114,11 +114,7 @@ pub fn guide_user_to_select_command(cli: &mut impl cli::traits::Cli) -> AnyhowRe
 			mode: None,
 		})),
 		#[cfg(feature = "contract")]
-		"contract" => Ok(Command::Contract(contract::NewContractCommand {
-			name: None,
-			contract_type: None,
-			template: None,
-		})),
+		"contract" => Ok(Command::Contract(contract::NewContractCommand { name: None, template: None })),
 		_ => Err(anyhow::anyhow!("Invalid selection")),
 	}
 }

crates/pop-cli/tests/contract.rs

@@ -5,7 +5,7 @@
 #![cfg(all(feature = "contract", feature = "integration-tests"))]
 
 use anyhow::Result;
-use pop_common::{find_free_port, pop, set_executable_permission, templates::Template};
+use pop_common::{find_free_port, pop, set_executable_permission};
 use pop_contracts::{
 	CallOpts, Contract, UpOpts, Weight, dry_run_call, dry_run_gas_estimate_call,
 	dry_run_gas_estimate_instantiate, ink_node_generator, instantiate_smart_contract, run_ink_node,
@@ -80,7 +80,8 @@ async fn contract_lifecycle() -> Result<()> {
 	// Test that all templates are generated correctly
 	generate_all_the_templates(&temp_dir)?;
 	// pop new contract test_contract (default)
-	let mut command = pop(&temp_dir, ["new", "contract", "test_contract"]);
+	let mut command =
+		pop(&temp_dir, ["new", "contract", "test_contract", "--template", "standard"]);
 	assert!(command.spawn()?.wait()?.success());
 	assert!(temp_dir.join("test_contract").exists());
 
@@ -275,22 +276,12 @@ async fn contract_lifecycle() -> Result<()> {
 fn generate_all_the_templates(temp_dir: &Path) -> Result<()> {
 	for template in Contract::VARIANTS {
 		let contract_name = format!("test_contract_{}", template).replace("-", "_");
-		let contract_type = template.template_type()?.to_lowercase();
-		// pop new chain test_parachain
+		// pop new contract test_contract
 		let mut command = pop(
 			&temp_dir,
-			[
-				"new",
-				"contract",
-				&contract_name,
-				"--contract-type",
-				&contract_type,
-				"--template",
-				&template.to_string(),
-			],
+			["new", "contract", &contract_name, "--template", &template.to_string()],
 		);
 		assert!(command.spawn()?.wait()?.success());
-		assert!(temp_dir.join(contract_name).exists());
 	}
 	Ok(())
 }

crates/pop-contracts/src/lib.rs

@@ -23,7 +23,7 @@ pub use new::{create_smart_contract, is_valid_contract_name};
 pub use node::{
 	eth_rpc_generator, ink_node_generator, is_chain_alive, run_eth_rpc_node, run_ink_node,
 };
-pub use templates::{Contract, ContractType};
+pub use templates::Contract;
 pub use test::test_e2e_smart_contract;
 pub use testing::{mock_build_process, new_environment};
 pub use up::{

crates/pop-contracts/src/new.rs

@@ -67,17 +67,12 @@ fn create_template_contract(
 	let temp_dir = ::tempfile::TempDir::new_in(std::env::temp_dir())?;
 	Git::clone(&Url::parse(template_repository)?, temp_dir.path(), None)?;
 	// Retrieve only the template contract files.
-	if template == &Contract::PSP22 || template == &Contract::PSP34 {
-		// Different template structure requires extracting different path
-		extract_template_files("", temp_dir.path(), canonicalized_path.as_path(), None)?;
-	} else {
-		extract_template_files(
-			template.as_ref(),
-			temp_dir.path(),
-			canonicalized_path.as_path(),
-			Some(vec!["frontend".to_string()]),
-		)?;
-	}
+	extract_template_files(
+		template.as_ref(),
+		temp_dir.path(),
+		canonicalized_path.as_path(),
+		Some(vec!["frontend".to_string()]),
+	)?;
 
 	// Replace name of the contract.
 	rename_contract(name, canonicalized_path, template)?;