(path: P, message: &str) -> Result +pub fn get_message(path: P, message: &str) -> Result where P: AsRef, { @@ -156,150 +157,6 @@ fn process_args( args } -// Formats a specified type, using the registry to output its full type representation. -fn format_type(ty: &Type, registry: &PortableRegistry) -> String { - let mut name = ty - .path - .segments - .last() - .map(|s| s.to_owned()) - .unwrap_or_else(|| ty.path.to_string()); - - if !ty.type_params.is_empty() { - let params: Vec<_> = ty - .type_params - .iter() - .filter_map(|p| registry.resolve(p.ty.unwrap().id)) - .map(|t| format_type(t, registry)) - .collect(); - name = format!("{name}<{}>", params.join(",")); - } - - name = format!( - "{name}{}", - match &ty.type_def { - TypeDef::Composite(composite) => { - if composite.fields.is_empty() { - return "".to_string(); - } - - let mut named = false; - let fields: Vec<_> = composite - .fields - .iter() - .filter_map(|f| match f.name.as_ref() { - None => registry.resolve(f.ty.id).map(|t| format_type(t, registry)), - Some(field) => { - named = true; - f.type_name.as_ref().map(|t| format!("{field}: {t}")) - }, - }) - .collect(); - match named { - true => format!(" {{ {} }}", fields.join(", ")), - false => format!(" ({})", fields.join(", ")), - } - }, - TypeDef::Variant(variant) => { - let variants: Vec<_> = variant - .variants - .iter() - .map(|v| { - if v.fields.is_empty() { - return v.name.clone(); - } - - let name = v.name.as_str(); - let mut named = false; - let fields: Vec<_> = v - .fields - .iter() - .filter_map(|f| match f.name.as_ref() { - None => registry.resolve(f.ty.id).map(|t| format_type(t, registry)), - Some(field) => { - named = true; - f.type_name.as_ref().map(|t| format!("{field}: {t}")) - }, - }) - .collect(); - format!( - "{name}{}", - match named { - true => format!("{{ {} }}", fields.join(", ")), - false => format!("({})", fields.join(", ")), - } - ) - }) - .collect(); - format!(": {}", variants.join(", ")) - }, - TypeDef::Sequence(sequence) => { - format!( - "[{}]", - format_type( - registry.resolve(sequence.type_param.id).expect("sequence type not found"), - registry - ) - ) - }, - TypeDef::Array(array) => { - format!( - "[{};{}]", - format_type( - registry.resolve(array.type_param.id).expect("array type not found"), - registry - ), - array.len - ) - }, - TypeDef::Tuple(tuple) => { - let fields: Vec<_> = tuple - .fields - .iter() - .filter_map(|p| registry.resolve(p.id)) - .map(|t| format_type(t, registry)) - .collect(); - format!("({})", fields.join(",")) - }, - TypeDef::Primitive(primitive) => { - use TypeDefPrimitive::*; - match primitive { - Bool => "bool", - Char => "char", - Str => "str", - U8 => "u8", - U16 => "u16", - U32 => "u32", - U64 => "u64", - U128 => "u128", - U256 => "u256", - I8 => "i8", - I16 => "i16", - I32 => "i32", - I64 => "i64", - I128 => "i128", - I256 => "i256", - } - .to_string() - }, - TypeDef::Compact(compact) => { - format!( - "Compact<{}>", - format_type( - registry.resolve(compact.type_param.id).expect("compact type not found"), - registry - ) - ) - }, - TypeDef::BitSequence(_) => { - unimplemented!("bit sequence not currently supported") - }, - } - ); - - name -} - /// Processes a list of argument values for a specified contract function, /// wrapping each value in `Some(...)` or replacing it with `None` if the argument is optional. /// diff --git a/crates/pop-contracts/src/utils/mod.rs b/crates/pop-contracts/src/utils/mod.rs index ad49e2dc6..a3a99323b 100644 --- a/crates/pop-contracts/src/utils/mod.rs +++ b/crates/pop-contracts/src/utils/mod.rs @@ -1,5 +1,149 @@ // SPDX-License-Identifier: GPL-3.0 -pub mod helpers; +use crate::errors::Error; +use contract_build::{util::decode_hex, ManifestPath}; +use contract_extrinsics::BalanceVariant; +use ink_env::{DefaultEnvironment, Environment}; +use pop_common::{Config, DefaultConfig}; +use sp_core::Bytes; +use std::{ + path::{Path, PathBuf}, + str::FromStr, +}; + pub mod metadata; -pub mod signer; + +/// Retrieves the manifest path for a contract project. +/// +/// # Arguments +/// * `path` - An optional path to the project directory. +pub fn get_manifest_path(path: Option<&Path>) -> Result { + if let Some(path) = path { + let full_path = PathBuf::from(path.to_string_lossy().to_string() + "/Cargo.toml"); + ManifestPath::try_from(Some(full_path)) + .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) + } else { + ManifestPath::try_from(path.as_ref()) + .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) + } +} + +/// Parses a balance value from a string representation. +/// +/// # Arguments +/// * `balance` - A string representing the balance value to parse. +pub fn parse_balance( + balance: &str, +) -> Result::Balance>, Error> { + BalanceVariant::from_str(balance).map_err(|e| Error::BalanceParsing(format!("{}", e))) +} + +/// Parses an account ID from its string representation. +/// +/// # Arguments +/// * `account` - A string representing the account ID to parse. +pub fn parse_account(account: &str) -> Result<::AccountId, Error> { + ::AccountId::from_str(account) + .map_err(|e| Error::AccountAddressParsing(format!("{}", e))) +} + +/// Parse hex encoded bytes. +/// +/// # Arguments +/// * `input` - A string containing hex-encoded bytes. +pub fn parse_hex_bytes(input: &str) -> Result { + let bytes = decode_hex(input).map_err(|e| Error::HexParsing(format!("{}", e)))?; + Ok(bytes.into()) +} + +/// Canonicalizes the given path to ensure consistency and resolve any symbolic links. +/// +/// # Arguments +/// * `target` - A reference to the `Path` to be canonicalized. +pub fn canonicalized_path(target: &Path) -> Result { + // Canonicalize the target path to ensure consistency and resolve any symbolic links. + target + .canonicalize() + // If an I/O error occurs during canonicalization, convert it into an Error enum variant. + .map_err(Error::IO) +} + +#[cfg(test)] +mod tests { + use super::*; + use anyhow::Result; + use std::fs; + + fn setup_test_environment() -> Result { + let temp_dir = tempfile::tempdir().expect("Could not create temp dir"); + let temp_contract_dir = temp_dir.path().join("test_contract"); + fs::create_dir(&temp_contract_dir)?; + crate::create_smart_contract( + "test_contract", + temp_contract_dir.as_path(), + &crate::Contract::Standard, + )?; + Ok(temp_dir) + } + + #[test] + fn test_get_manifest_path() -> Result<(), Error> { + let temp_dir = setup_test_environment()?; + get_manifest_path(Some(&PathBuf::from(temp_dir.path().join("test_contract"))))?; + Ok(()) + } + + #[test] + fn test_canonicalized_path() -> Result<(), Error> { + let temp_dir = tempfile::tempdir()?; + // Error case + let error_directory = canonicalized_path(&temp_dir.path().join("my_directory")); + assert!(error_directory.is_err()); + // Success case + canonicalized_path(temp_dir.path())?; + Ok(()) + } + + #[test] + fn parse_balance_works() -> Result<(), Error> { + let balance = parse_balance("100000")?; + assert_eq!(balance, BalanceVariant::Default(100000)); + Ok(()) + } + + #[test] + fn parse_balance_fails_wrong_balance() -> Result<(), Error> { + assert!(matches!(parse_balance("wrongbalance"), Err(super::Error::BalanceParsing(..)))); + Ok(()) + } + + #[test] + fn parse_account_works() -> Result<(), Error> { + let account = parse_account("5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A")?; + assert_eq!(account.to_string(), "5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A"); + Ok(()) + } + + #[test] + fn parse_account_fails_wrong_value() -> Result<(), Error> { + assert!(matches!( + parse_account("wrongaccount"), + Err(super::Error::AccountAddressParsing(..)) + )); + Ok(()) + } + + #[test] + fn parse_hex_bytes_works() -> Result<(), Error> { + let input_in_hex = "48656c6c6f"; + let result = parse_hex_bytes(input_in_hex)?; + assert_eq!(result, Bytes(vec![72, 101, 108, 108, 111])); + Ok(()) + } + + #[test] + fn parse_hex_bytes_fails_wrong_input() -> Result<()> { + assert!(matches!(parse_hex_bytes("wronghexvalue"), Err(Error::HexParsing(..)))); + Ok(()) + } +} diff --git a/crates/pop-contracts/tests/files/testing.wasm b/crates/pop-contracts/tests/files/testing.wasm index 430888669..e69de29bb 100644 Binary files a/crates/pop-contracts/tests/files/testing.wasm and b/crates/pop-contracts/tests/files/testing.wasm differ diff --git a/crates/pop-parachains/Cargo.toml b/crates/pop-parachains/Cargo.toml index dd6406824..619b3336e 100644 --- a/crates/pop-parachains/Cargo.toml +++ b/crates/pop-parachains/Cargo.toml @@ -12,12 +12,12 @@ version.workspace = true anyhow.workspace = true clap.workspace = true duct.workspace = true -flate2.workspace = true glob.workspace = true serde_json.workspace = true strum.workspace = true strum_macros.workspace = true -tar.workspace = true +subxt-signer.workspace = true +subxt.workspace = true tempfile.workspace = true thiserror.workspace = true tokio.workspace = true @@ -25,7 +25,9 @@ url.workspace = true askama.workspace = true indexmap.workspace = true -reqwest.workspace = true +scale-info.workspace = true +scale-value.workspace = true +sp-core.workspace = true symlink.workspace = true toml_edit.workspace = true walkdir.workspace = true @@ -33,8 +35,8 @@ walkdir.workspace = true zombienet-sdk.workspace = true # Pop -pop-common = { path = "../pop-common", version = "0.5.0" } +pop-common = { path = "../pop-common", version = "0.6.0" } [dev-dependencies] -mockito.workspace = true +# Used in doc tests. tokio-test.workspace = true diff --git a/crates/pop-parachains/src/call/metadata/action.rs b/crates/pop-parachains/src/call/metadata/action.rs new file mode 100644 index 000000000..1e8298fc7 --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/action.rs @@ -0,0 +1,211 @@ +// SPDX-License-Identifier: GPL-3.0 + +use super::{find_dispatchable_by_name, Pallet}; +use strum::{EnumMessage as _, EnumProperty as _, VariantArray as _}; +use strum_macros::{AsRefStr, Display, EnumMessage, EnumProperty, EnumString, VariantArray}; + +/// Enum representing various predefined actions supported. +#[derive( + AsRefStr, + Clone, + Debug, + Display, + EnumMessage, + EnumString, + EnumProperty, + Eq, + Hash, + PartialEq, + VariantArray, +)] +pub enum Action { + /// Transfer balance. + #[strum( + serialize = "transfer", + message = "transfer_allow_death", + detailed_message = "Transfer balance", + props(Pallet = "Balances") + )] + Transfer, + /// Create an asset. + #[strum( + serialize = "create", + message = "create", + detailed_message = "Create an asset", + props(Pallet = "Assets") + )] + CreateAsset, + /// Mint an asset. + #[strum( + serialize = "mint", + message = "mint", + detailed_message = "Mint an asset", + props(Pallet = "Assets") + )] + MintAsset, + /// Create a NFT collection. + #[strum( + serialize = "create_nft", + message = "create", + detailed_message = "Create a NFT collection", + props(Pallet = "Nfts") + )] + CreateCollection, + /// Mint a NFT. + #[strum( + serialize = "mint_nft", + message = "mint", + detailed_message = "Mint a NFT", + props(Pallet = "Nfts") + )] + MintNFT, + /// Purchase on-demand coretime. + #[strum( + serialize = "place_order_allow_death", + message = "place_order_allow_death", + detailed_message = "Purchase on-demand coretime", + props(Pallet = "OnDemand") + )] + PurchaseOnDemandCoretime, + /// Reserve a parachain ID. + #[strum( + serialize = "reserve", + message = "reserve", + detailed_message = "Reserve a parachain ID", + props(Pallet = "Registrar") + )] + Reserve, + /// Register a parachain ID with genesis state and code. + #[strum( + serialize = "register", + message = "register", + detailed_message = "Register a parachain ID with genesis state and code", + props(Pallet = "Registrar") + )] + Register, + /// Make a remark. + #[strum( + serialize = "remark", + message = "remark_with_event", + detailed_message = "Make a remark", + props(Pallet = "System") + )] + Remark, +} + +impl Action { + /// Get the description of the action. + pub fn description(&self) -> &str { + self.get_detailed_message().unwrap_or_default() + } + + /// Get the dispatchable function name corresponding to the action. + pub fn function_name(&self) -> &str { + self.get_message().unwrap_or_default() + } + + /// Get the associated pallet name for the action. + pub fn pallet_name(&self) -> &str { + self.get_str("Pallet").unwrap_or_default() + } +} + +/// Fetch the list of supported actions based on available pallets. +/// +/// # Arguments +/// * `pallets`: Supported pallets. +pub fn supported_actions(pallets: &[Pallet]) -> Vec { + let mut actions = Vec::new(); + for action in Action::VARIANTS.iter() { + if find_dispatchable_by_name(pallets, action.pallet_name(), action.function_name()).is_ok() + { + actions.push(action.clone()); + } + } + actions +} + +#[cfg(test)] +mod tests { + use super::{Action::*, *}; + use crate::{call::tests::POP_NETWORK_TESTNET_URL, parse_chain_metadata, set_up_client}; + use anyhow::Result; + use std::collections::HashMap; + + const POLKADOT_NETWORK_URL: &str = "wss://polkadot-rpc.publicnode.com"; + + #[test] + fn action_descriptions_are_correct() { + let descriptions = HashMap::from([ + (CreateAsset, "Create an asset"), + (MintAsset, "Mint an asset"), + (CreateCollection, "Create a NFT collection"), + (MintNFT, "Mint a NFT"), + (PurchaseOnDemandCoretime, "Purchase on-demand coretime"), + (Transfer, "Transfer balance"), + (Register, "Register a parachain ID with genesis state and code"), + (Reserve, "Reserve a parachain ID"), + (Remark, "Make a remark"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.description(), descriptions.get(action).unwrap()); + } + } + + #[test] + fn pallet_names_are_correct() { + let pallets = HashMap::from([ + (CreateAsset, "Assets"), + (MintAsset, "Assets"), + (CreateCollection, "Nfts"), + (MintNFT, "Nfts"), + (PurchaseOnDemandCoretime, "OnDemand"), + (Transfer, "Balances"), + (Register, "Registrar"), + (Reserve, "Registrar"), + (Remark, "System"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.pallet_name(), pallets.get(action).unwrap(),); + } + } + + #[test] + fn function_names_are_correct() { + let pallets = HashMap::from([ + (CreateAsset, "create"), + (MintAsset, "mint"), + (CreateCollection, "create"), + (MintNFT, "mint"), + (PurchaseOnDemandCoretime, "place_order_allow_death"), + (Transfer, "transfer_allow_death"), + (Register, "register"), + (Reserve, "reserve"), + (Remark, "remark_with_event"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.function_name(), pallets.get(action).unwrap(),); + } + } + + #[tokio::test] + async fn supported_actions_works() -> Result<()> { + // Test Pop Parachain. + let mut client: subxt::OnlineClient = + set_up_client(POP_NETWORK_TESTNET_URL).await?; + let actions = supported_actions(&parse_chain_metadata(&client)?); + assert_eq!( + actions, + vec![Transfer, CreateAsset, MintAsset, CreateCollection, MintNFT, Remark] + ); + + // Test Polkadot Relay Chain. + client = set_up_client(POLKADOT_NETWORK_URL).await?; + let actions = supported_actions(&parse_chain_metadata(&client)?); + assert_eq!(actions, vec![Transfer, PurchaseOnDemandCoretime, Reserve, Register, Remark]); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/metadata/mod.rs b/crates/pop-parachains/src/call/metadata/mod.rs new file mode 100644 index 000000000..5a9a9a2cb --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/mod.rs @@ -0,0 +1,335 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::errors::Error; +use params::Param; +use scale_value::stringify::custom_parsers; +use std::fmt::{Display, Formatter}; +use subxt::{dynamic::Value, utils::to_hex, Metadata, OnlineClient, SubstrateConfig}; + +pub mod action; +pub mod params; + +/// Represents a pallet in the blockchain, including its dispatchable functions. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Pallet { + /// The name of the pallet. + pub name: String, + /// The index of the pallet within the runtime. + pub index: u8, + /// The documentation of the pallet. + pub docs: String, + /// The dispatchable functions of the pallet. + pub functions: Vec, +} + +impl Display for Pallet { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name) + } +} + +/// Represents a dispatchable function. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Function { + /// The pallet containing the dispatchable function. + pub pallet: String, + /// The name of the function. + pub name: String, + /// The index of the function within the pallet. + pub index: u8, + /// The documentation of the function. + pub docs: String, + /// The parameters of the function. + pub params: Vec, + /// Whether this function is supported (no recursive or unsupported types like `RuntimeCall`). + pub is_supported: bool, +} + +impl Display for Function { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name) + } +} + +/// Parses the chain metadata to extract information about pallets and their dispatchable functions. +/// +/// # Arguments +/// * `client`: The client to interact with the chain. +/// +/// NOTE: pallets are ordered by their index within the runtime by default. +pub fn parse_chain_metadata(client: &OnlineClient) -> Result, Error> { + let metadata: Metadata = client.metadata(); + + let pallets = metadata + .pallets() + .map(|pallet| { + let functions = pallet + .call_variants() + .map(|variants| { + variants + .iter() + .map(|variant| { + let mut is_supported = true; + + // Parse parameters for the dispatchable function. + let params = { + let mut parsed_params = Vec::new(); + for field in &variant.fields { + match params::field_to_param(&metadata, field) { + Ok(param) => parsed_params.push(param), + Err(_) => { + // If an error occurs while parsing the values, mark the + // dispatchable function as unsupported rather than + // error. + is_supported = false; + parsed_params.clear(); + break; + }, + } + } + parsed_params + }; + + Ok(Function { + pallet: pallet.name().to_string(), + name: variant.name.clone(), + index: variant.index, + docs: if is_supported { + // Filter out blank lines and then flatten into a single value. + variant + .docs + .iter() + .filter(|l| !l.is_empty()) + .cloned() + .collect::>() + .join(" ") + } else { + // To display the message in the UI + "Function Not Supported".to_string() + }, + params, + is_supported, + }) + }) + .collect::, Error>>() + }) + .unwrap_or_else(|| Ok(vec![]))?; + + Ok(Pallet { + name: pallet.name().to_string(), + index: pallet.index(), + docs: pallet.docs().join(" "), + functions, + }) + }) + .collect::, Error>>()?; + + Ok(pallets) +} + +/// Finds a specific pallet by name and retrieves its details from metadata. +/// +/// # Arguments +/// * `pallets`: List of pallets available within the chain's runtime. +/// * `pallet_name`: The name of the pallet to find. +pub fn find_pallet_by_name<'a>( + pallets: &'a [Pallet], + pallet_name: &str, +) -> Result<&'a Pallet, Error> { + if let Some(pallet) = pallets.iter().find(|p| p.name == pallet_name) { + Ok(pallet) + } else { + Err(Error::PalletNotFound(pallet_name.to_string())) + } +} + +/// Finds a specific dispatchable function by name and retrieves its details from metadata. +/// +/// # Arguments +/// * `pallets`: List of pallets available within the chain's runtime. +/// * `pallet_name`: The name of the pallet. +/// * `function_name`: Name of the dispatchable function to locate. +pub fn find_dispatchable_by_name<'a>( + pallets: &'a [Pallet], + pallet_name: &str, + function_name: &str, +) -> Result<&'a Function, Error> { + let pallet = find_pallet_by_name(pallets, pallet_name)?; + if let Some(function) = pallet.functions.iter().find(|&e| e.name == function_name) { + Ok(function) + } else { + Err(Error::FunctionNotSupported) + } +} + +/// Parses and processes raw string parameter values for a dispatchable function, mapping them to +/// `Value` types. +/// +/// # Arguments +/// * `params`: The metadata definition for each parameter of the corresponding dispatchable +/// function. +/// * `raw_params`: A vector of raw string arguments for the dispatchable function. +pub fn parse_dispatchable_arguments( + params: &[Param], + raw_params: Vec, +) -> Result, Error> { + params + .iter() + .zip(raw_params) + .map(|(param, raw_param)| { + // Convert sequence parameters to hex if is_sequence + let processed_param = if param.is_sequence && !raw_param.starts_with("0x") { + to_hex(&raw_param) + } else { + raw_param + }; + scale_value::stringify::from_str_custom() + .add_custom_parser(custom_parsers::parse_hex) + .add_custom_parser(custom_parsers::parse_ss58) + .parse(&processed_param) + .0 + .map_err(|_| Error::ParamProcessingError) + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + use crate::{call::tests::POP_NETWORK_TESTNET_URL, set_up_client}; + use anyhow::Result; + use sp_core::bytes::from_hex; + use subxt::ext::scale_bits; + + #[tokio::test] + async fn parse_chain_metadata_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + // Test the first pallet is parsed correctly + let first_pallet = pallets.first().unwrap(); + assert_eq!(first_pallet.name, "System"); + assert_eq!(first_pallet.index, 0); + assert_eq!(first_pallet.docs, ""); + assert_eq!(first_pallet.functions.len(), 11); + let first_function = first_pallet.functions.first().unwrap(); + assert_eq!(first_function.name, "remark"); + assert_eq!(first_function.index, 0); + assert_eq!( + first_function.docs, + "Make some on-chain remark. Can be executed by every `origin`." + ); + assert!(first_function.is_supported); + assert_eq!(first_function.params.first().unwrap().name, "remark"); + assert_eq!(first_function.params.first().unwrap().type_name, "[u8]"); + assert_eq!(first_function.params.first().unwrap().sub_params.len(), 0); + assert!(!first_function.params.first().unwrap().is_optional); + assert!(!first_function.params.first().unwrap().is_tuple); + assert!(!first_function.params.first().unwrap().is_variant); + assert!(first_function.params.first().unwrap().is_sequence); + Ok(()) + } + + #[tokio::test] + async fn find_pallet_by_name_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + assert!(matches!( + find_pallet_by_name(&pallets, "WrongName"), + Err(Error::PalletNotFound(pallet)) if pallet == "WrongName".to_string())); + let pallet = find_pallet_by_name(&pallets, "Balances")?; + assert_eq!(pallet.name, "Balances"); + assert_eq!(pallet.functions.len(), 9); + Ok(()) + } + + #[tokio::test] + async fn find_dispatchable_by_name_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + assert!(matches!( + find_dispatchable_by_name(&pallets, "WrongName", "wrong_name"), + Err(Error::PalletNotFound(pallet)) if pallet == "WrongName".to_string())); + assert!(matches!( + find_dispatchable_by_name(&pallets, "Balances", "wrong_name"), + Err(Error::FunctionNotSupported) + )); + let function = find_dispatchable_by_name(&pallets, "Balances", "force_transfer")?; + assert_eq!(function.name, "force_transfer"); + assert_eq!(function.docs, "Exactly as `transfer_allow_death`, except the origin must be root and the source account may be specified."); + assert_eq!(function.is_supported, true); + assert_eq!(function.params.len(), 3); + Ok(()) + } + + #[test] + fn parse_dispatchable_arguments_works() -> Result<()> { + // Values for testing from: https://docs.rs/scale-value/0.18.0/scale_value/stringify/fn.from_str.html + // and https://docs.rs/scale-value/0.18.0/scale_value/stringify/fn.from_str_custom.html + let args = [ + "1".to_string(), + "-1".to_string(), + "true".to_string(), + "'a'".to_string(), + "\"hi\"".to_string(), + "{ a: true, b: \"hello\" }".to_string(), + "MyVariant { a: true, b: \"hello\" }".to_string(), + "<0101>".to_string(), + "(1,2,0x030405)".to_string(), + r#"{ + name: "Alice", + address: 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty + }"# + .to_string(), + ] + .to_vec(); + let addr: Vec<_> = + from_hex("8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48") + .unwrap() + .into_iter() + .map(|b| Value::u128(b as u128)) + .collect(); + // Define mock dispatchable function parameters for testing. + let params = vec![ + Param { type_name: "u128".to_string(), ..Default::default() }, + Param { type_name: "i128".to_string(), ..Default::default() }, + Param { type_name: "bool".to_string(), ..Default::default() }, + Param { type_name: "char".to_string(), ..Default::default() }, + Param { type_name: "string".to_string(), ..Default::default() }, + Param { type_name: "compostie".to_string(), ..Default::default() }, + Param { type_name: "variant".to_string(), is_variant: true, ..Default::default() }, + Param { type_name: "bit_sequence".to_string(), ..Default::default() }, + Param { type_name: "tuple".to_string(), is_tuple: true, ..Default::default() }, + Param { type_name: "composite".to_string(), ..Default::default() }, + ]; + assert_eq!( + parse_dispatchable_arguments(¶ms, args)?, + [ + Value::u128(1), + Value::i128(-1), + Value::bool(true), + Value::char('a'), + Value::string("hi"), + Value::named_composite(vec![ + ("a", Value::bool(true)), + ("b", Value::string("hello")) + ]), + Value::named_variant( + "MyVariant", + vec![("a", Value::bool(true)), ("b", Value::string("hello"))] + ), + Value::bit_sequence(scale_bits::Bits::from_iter([false, true, false, true])), + Value::unnamed_composite(vec![ + Value::u128(1), + Value::u128(2), + Value::unnamed_composite(vec![Value::u128(3), Value::u128(4), Value::u128(5),]) + ]), + Value::named_composite(vec![ + ("name", Value::string("Alice")), + ("address", Value::unnamed_composite(addr)) + ]) + ] + ); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/metadata/params.rs b/crates/pop-parachains/src/call/metadata/params.rs new file mode 100644 index 000000000..9d8521f9c --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/params.rs @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::errors::Error; +use pop_common::format_type; +use scale_info::{form::PortableForm, Field, PortableRegistry, TypeDef}; +use subxt::Metadata; + +/// Describes a parameter of a dispatchable function. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Param { + /// The name of the parameter. + pub name: String, + /// The type of the parameter. + pub type_name: String, + /// Nested parameters for composite, variants, types or tuples. + pub sub_params: Vec, + /// Indicates if the parameter is optional (`Option`). + pub is_optional: bool, + /// Indicates if the parameter is a Tuple. + pub is_tuple: bool, + /// Indicates if the parameter is a Variant. + pub is_variant: bool, + /// Indicates if the parameter is a Sequence. + pub is_sequence: bool, +} + +/// Transforms a metadata field into its `Param` representation. +/// +/// # Arguments +/// * `metadata`: The chain metadata. +/// * `field`: A parameter of a dispatchable function (as [Field]). +pub fn field_to_param(metadata: &Metadata, field: &Field) -> Result { + let registry = metadata.types(); + if let Some(name) = field.type_name.as_deref() { + if name.contains("RuntimeCall") { + return Err(Error::FunctionNotSupported); + } + } + let name = field.name.as_deref().unwrap_or("Unnamed"); //It can be unnamed field + type_to_param(name, registry, field.ty.id) +} + +/// Converts a type's metadata into a `Param` representation. +/// +/// # Arguments +/// * `name`: The name of the parameter. +/// * `registry`: Type registry containing all types used in the metadata. +/// * `type_id`: The ID of the type to be converted. +fn type_to_param(name: &str, registry: &PortableRegistry, type_id: u32) -> Result { + let type_info = registry + .resolve(type_id) + .ok_or_else(|| Error::MetadataParsingError(name.to_string()))?; + for param in &type_info.type_params { + if param.name.contains("RuntimeCall") { + return Err(Error::FunctionNotSupported); + } + } + if type_info.path.segments == ["Option"] { + if let Some(sub_type_id) = type_info.type_params.first().and_then(|param| param.ty) { + // Recursive for the sub parameters + let sub_param = type_to_param(name, registry, sub_type_id.id)?; + Ok(Param { + name: name.to_string(), + type_name: sub_param.type_name, + sub_params: sub_param.sub_params, + is_optional: true, + ..Default::default() + }) + } else { + Err(Error::MetadataParsingError(name.to_string())) + } + } else { + // Determine the formatted type name. + let type_name = format_type(type_info, registry); + match &type_info.type_def { + TypeDef::Primitive(_) | TypeDef::Array(_) | TypeDef::Compact(_) => + Ok(Param { name: name.to_string(), type_name, ..Default::default() }), + TypeDef::Composite(composite) => { + let sub_params = composite + .fields + .iter() + .map(|field| { + // Recursive for the sub parameters of composite type. + type_to_param(field.name.as_deref().unwrap_or(name), registry, field.ty.id) + }) + .collect::, Error>>()?; + + Ok(Param { name: name.to_string(), type_name, sub_params, ..Default::default() }) + }, + TypeDef::Variant(variant) => { + let variant_params = variant + .variants + .iter() + .map(|variant_param| { + let variant_sub_params = variant_param + .fields + .iter() + .map(|field| { + // Recursive for the sub parameters of variant type. + type_to_param( + field.name.as_deref().unwrap_or(&variant_param.name), + registry, + field.ty.id, + ) + }) + .collect::, Error>>()?; + Ok(Param { + name: variant_param.name.clone(), + type_name: "".to_string(), + sub_params: variant_sub_params, + is_variant: true, + ..Default::default() + }) + }) + .collect::, Error>>()?; + + Ok(Param { + name: name.to_string(), + type_name, + sub_params: variant_params, + is_variant: true, + ..Default::default() + }) + }, + TypeDef::Sequence(_) => Ok(Param { + name: name.to_string(), + type_name, + is_sequence: true, + ..Default::default() + }), + TypeDef::Tuple(tuple) => { + let sub_params = tuple + .fields + .iter() + .enumerate() + .map(|(index, field_id)| { + type_to_param( + &format!("Index {index} of the tuple {name}"), + registry, + field_id.id, + ) + }) + .collect::, Error>>()?; + + Ok(Param { + name: name.to_string(), + type_name, + sub_params, + is_tuple: true, + ..Default::default() + }) + }, + _ => Err(Error::MetadataParsingError(name.to_string())), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{call::tests::POP_NETWORK_TESTNET_URL, set_up_client}; + use anyhow::Result; + + #[tokio::test] + async fn field_to_param_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let metadata = client.metadata(); + // Test a supported dispatchable function. + let function = metadata + .pallet_by_name("Balances") + .unwrap() + .call_variant_by_name("force_transfer") + .unwrap(); + let mut params = Vec::new(); + for field in &function.fields { + params.push(field_to_param(&metadata, field)?) + } + assert_eq!(params.len(), 3); + assert_eq!(params.first().unwrap().name, "source"); + assert_eq!(params.first().unwrap().type_name, "MultiAddress: Id(AccountId32 ([u8;32])), Index(Compact<()>), Raw([u8]), Address32([u8;32]), Address20([u8;20])"); + assert_eq!(params.first().unwrap().sub_params.len(), 5); + assert_eq!(params.first().unwrap().sub_params.first().unwrap().name, "Id"); + assert_eq!(params.first().unwrap().sub_params.first().unwrap().type_name, ""); + assert_eq!( + params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .name, + "Id" + ); + assert_eq!( + params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .type_name, + "AccountId32 ([u8;32])" + ); + // Test some dispatchable functions that are not supported. + let function = + metadata.pallet_by_name("Sudo").unwrap().call_variant_by_name("sudo").unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + let function = metadata + .pallet_by_name("Utility") + .unwrap() + .call_variant_by_name("batch") + .unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + let function = metadata + .pallet_by_name("PolkadotXcm") + .unwrap() + .call_variant_by_name("execute") + .unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/mod.rs b/crates/pop-parachains/src/call/mod.rs new file mode 100644 index 000000000..4569687ec --- /dev/null +++ b/crates/pop-parachains/src/call/mod.rs @@ -0,0 +1,263 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::{errors::Error, Function}; +use pop_common::{ + call::{DefaultEnvironment, DisplayEvents, TokenMetadata, Verbosity}, + create_signer, +}; +use sp_core::bytes::{from_hex, to_hex}; +use subxt::{ + dynamic::Value, + tx::{DynamicPayload, Payload, SubmittableExtrinsic}, + OnlineClient, SubstrateConfig, +}; +pub mod metadata; + +/// Sets up an [OnlineClient] instance for connecting to a blockchain. +/// +/// # Arguments +/// * `url` - Endpoint of the node. +pub async fn set_up_client(url: &str) -> Result, Error> { + OnlineClient::::from_url(url) + .await + .map_err(|e| Error::ConnectionFailure(e.to_string())) +} + +/// Constructs a dynamic extrinsic payload for a specified dispatchable function. +/// +/// # Arguments +/// * `function` - A dispatchable function. +/// * `args` - A vector of string arguments to be passed to construct the extrinsic. +pub fn construct_extrinsic( + function: &Function, + args: Vec, +) -> Result { + let parsed_args: Vec = metadata::parse_dispatchable_arguments(&function.params, args)?; + Ok(subxt::dynamic::tx(function.pallet.clone(), function.name.clone(), parsed_args)) +} + +/// Constructs a Sudo extrinsic. +/// +/// # Arguments +/// * `xt`: The extrinsic representing the dispatchable function call to be dispatched with `Root` +/// privileges. +pub fn construct_sudo_extrinsic(xt: DynamicPayload) -> DynamicPayload { + subxt::dynamic::tx("Sudo", "sudo", [xt.into_value()].to_vec()) +} + +/// Signs and submits a given extrinsic. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `url` - Endpoint of the node. +/// * `xt` - The (encoded) extrinsic to be signed and submitted. +/// * `suri` - The secret URI (e.g., mnemonic or private key) for signing the extrinsic. +pub async fn sign_and_submit_extrinsic( + client: &OnlineClient, + url: &url::Url, + xt: Xt, + suri: &str, +) -> Result { + let signer = create_signer(suri)?; + let result = client + .tx() + .sign_and_submit_then_watch_default(&xt, &signer) + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))? + .wait_for_finalized_success() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))?; + + // Obtain required metadata and parse events. The following is using existing logic from + // `cargo-contract`, also used in calling contracts, due to simplicity and can be refactored in + // the future. + let metadata = client.metadata(); + let token_metadata = TokenMetadata::query::(url).await?; + let events = DisplayEvents::from_events::( + &result, None, &metadata, + )?; + let events = + events.display_events::(Verbosity::Default, &token_metadata)?; + + Ok(format!("Extrinsic Submitted with hash: {:?}\n\n{}", result.extrinsic_hash(), events)) +} + +/// Submits a signed extrinsic. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `payload` - The signed payload string to be submitted. +pub async fn submit_signed_extrinsic( + client: OnlineClient, + payload: String, +) -> Result { + let hex_encoded = + from_hex(&payload).map_err(|e| Error::CallDataDecodingError(e.to_string()))?; + let extrinsic = SubmittableExtrinsic::from_bytes(client, hex_encoded); + let result = extrinsic + .submit_and_watch() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))? + .wait_for_finalized_success() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))?; + Ok(format!("{:?}", result.extrinsic_hash())) +} + +/// Encodes the call data for a given extrinsic into a hexadecimal string. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `xt` - The extrinsic whose call data will be encoded and returned. +pub fn encode_call_data( + client: &OnlineClient, + xt: &DynamicPayload, +) -> Result { + let call_data = xt + .encode_call_data(&client.metadata()) + .map_err(|e| Error::CallDataEncodingError(e.to_string()))?; + Ok(to_hex(&call_data, false)) +} + +/// Decodes a hex-encoded string into a vector of bytes representing the call data. +/// +/// # Arguments +/// * `call_data` - The hex-encoded string representing call data. +pub fn decode_call_data(call_data: &str) -> Result, Error> { + from_hex(call_data).map_err(|e| Error::CallDataDecodingError(e.to_string())) +} + +/// This struct implements the [`Payload`] trait and is used to submit +/// pre-encoded SCALE call data directly, without the dynamic construction of transactions. +pub struct CallData(Vec); + +impl CallData { + /// Create a new instance of `CallData`. + pub fn new(data: Vec) -> CallData { + CallData(data) + } +} + +impl Payload for CallData { + fn encode_call_data_to( + &self, + _: &subxt::Metadata, + out: &mut Vec, + ) -> Result<(), subxt::ext::subxt_core::Error> { + out.extend_from_slice(&self.0); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{find_dispatchable_by_name, parse_chain_metadata, set_up_client}; + use anyhow::Result; + use url::Url; + + const ALICE_SURI: &str = "//Alice"; + pub(crate) const POP_NETWORK_TESTNET_URL: &str = "wss://rpc1.paseo.popnetwork.xyz"; + + #[tokio::test] + async fn set_up_client_works() -> Result<()> { + assert!(matches!( + set_up_client("wss://wronguri.xyz").await, + Err(Error::ConnectionFailure(_)) + )); + set_up_client(POP_NETWORK_TESTNET_URL).await?; + Ok(()) + } + + #[tokio::test] + async fn construct_extrinsic_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let transfer_allow_death = + find_dispatchable_by_name(&pallets, "Balances", "transfer_allow_death")?; + + // Wrong parameters + assert!(matches!( + construct_extrinsic( + &transfer_allow_death, + vec![ALICE_SURI.to_string(), "100".to_string()], + ), + Err(Error::ParamProcessingError) + )); + // Valid parameters + let xt = construct_extrinsic( + &transfer_allow_death, + vec![ + "Id(5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty)".to_string(), + "100".to_string(), + ], + )?; + assert_eq!(xt.call_name(), "transfer_allow_death"); + assert_eq!(xt.pallet_name(), "Balances"); + Ok(()) + } + + #[tokio::test] + async fn encode_call_data_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let remark = find_dispatchable_by_name(&pallets, "System", "remark")?; + let xt = construct_extrinsic(&remark, vec!["0x11".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00000411"); + let xt = construct_extrinsic(&remark, vec!["123".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00000c313233"); + let xt = construct_extrinsic(&remark, vec!["test".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00001074657374"); + Ok(()) + } + + #[tokio::test] + async fn decode_call_data_works() -> Result<()> { + assert!(matches!(decode_call_data("wrongcalldata"), Err(Error::CallDataDecodingError(..)))); + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let remark = find_dispatchable_by_name(&pallets, "System", "remark")?; + let xt = construct_extrinsic(&remark, vec!["0x11".to_string()])?; + let expected_call_data = xt.encode_call_data(&client.metadata())?; + assert_eq!(decode_call_data("0x00000411")?, expected_call_data); + Ok(()) + } + + #[tokio::test] + async fn sign_and_submit_wrong_extrinsic_fails() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let function = Function { + pallet: "WrongPallet".to_string(), + name: "wrong_extrinsic".to_string(), + index: 0, + docs: "documentation".to_string(), + is_supported: true, + ..Default::default() + }; + let xt = construct_extrinsic(&function, vec!["0x11".to_string()])?; + assert!(matches!( + sign_and_submit_extrinsic(&client, &Url::parse(POP_NETWORK_TESTNET_URL)?, xt, ALICE_SURI).await, + Err(Error::ExtrinsicSubmissionError(message)) if message.contains("PalletNameNotFound(\"WrongPallet\"))") + )); + Ok(()) + } + + #[tokio::test] + async fn construct_sudo_extrinsic_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let force_transfer = find_dispatchable_by_name(&pallets, "Balances", "force_transfer")?; + let xt = construct_extrinsic( + &force_transfer, + vec![ + "Id(5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty)".to_string(), + "Id(5DAAnrj7VHTznn2AWBemMuyBwZWs6FNFjdyVXUeYum3PTXFy)".to_string(), + "100".to_string(), + ], + )?; + let xt = construct_sudo_extrinsic(xt); + assert_eq!(xt.call_name(), "sudo"); + assert_eq!(xt.pallet_name(), "Sudo"); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/errors.rs b/crates/pop-parachains/src/errors.rs index 3eff7bbfc..2dd8805ac 100644 --- a/crates/pop-parachains/src/errors.rs +++ b/crates/pop-parachains/src/errors.rs @@ -3,24 +3,43 @@ use thiserror::Error; use zombienet_sdk::OrchestratorError; +/// Represents the various errors that can occur in the crate. #[derive(Error, Debug)] pub enum Error { #[error("User aborted due to existing target directory.")] Aborted, #[error("Anyhow error: {0}")] AnyhowError(#[from] anyhow::Error), + /// An error occurred while decoding the call data. + #[error("Failed to decode call data. {0}")] + CallDataDecodingError(String), + /// An error occurred while encoding the call data. + #[error("Failed to encode call data. {0}")] + CallDataEncodingError(String), #[error("{0}")] CommonError(#[from] pop_common::Error), + /// An error occurred while attempting to establish a connection to the endpoint. + #[error("Failed to establish a connection to: {0}")] + ConnectionFailure(String), #[error("Configuration error: {0}")] Config(String), #[error("Failed to access the current directory")] CurrentDirAccess, #[error("Failed to parse the endowment value")] EndowmentError, + /// An error occurred during the submission of an extrinsic. + #[error("Extrinsic submission error: {0}")] + ExtrinsicSubmissionError(String), + /// The dispatchable function is not supported. + #[error("The dispatchable function is not supported")] + FunctionNotSupported, #[error("IO error: {0}")] IO(#[from] std::io::Error), #[error("JSON error: {0}")] JsonError(#[from] serde_json::Error), + /// An error occurred while parsing metadata of a parameter. + #[error("Error parsing metadata for parameter {0}")] + MetadataParsingError(String), #[error("Missing binary: {0}")] MissingBinary(String), #[error("Missing chain spec file at: {0}")] @@ -31,12 +50,21 @@ pub enum Error { OrchestratorError(#[from] OrchestratorError), #[error("Failed to create pallet directory")] PalletDirCreation, + /// The specified pallet could not be found. + #[error("Failed to find the pallet {0}")] + PalletNotFound(String), + /// An error occurred while processing the arguments provided by the user. + #[error("Failed to process the arguments provided by the user.")] + ParamProcessingError, #[error("Invalid path")] PathError, #[error("Failed to execute rustfmt")] RustfmtError(std::io::Error), #[error("Template error: {0}")] SourcingError(#[from] pop_common::sourcing::Error), + /// An error occurred whilst interacting with a chain using `subxt`. + #[error("Subxt error: {0}")] + SubXtError(#[from] subxt::Error), #[error("Toml error: {0}")] TomlError(#[from] toml_edit::de::Error), #[error("Unsupported command: {0}")] diff --git a/crates/pop-parachains/src/lib.rs b/crates/pop-parachains/src/lib.rs index 06bee8f4a..50bb6af5b 100644 --- a/crates/pop-parachains/src/lib.rs +++ b/crates/pop-parachains/src/lib.rs @@ -2,10 +2,13 @@ #![doc = include_str!("../README.md")] mod build; +/// Provides functionality to construct, encode, sign, and submit chain extrinsics. +mod call; mod errors; mod generator; mod new_pallet; mod new_parachain; +mod relay; mod templates; mod up; mod utils; @@ -14,10 +17,26 @@ pub use build::{ binary_path, build_parachain, export_wasm_file, generate_genesis_state_file, generate_plain_chain_spec, generate_raw_chain_spec, is_supported, ChainSpec, }; +pub use call::{ + construct_extrinsic, construct_sudo_extrinsic, decode_call_data, encode_call_data, + metadata::{ + action::{supported_actions, Action}, + find_dispatchable_by_name, find_pallet_by_name, + params::Param, + parse_chain_metadata, Function, Pallet, + }, + set_up_client, sign_and_submit_extrinsic, submit_signed_extrinsic, CallData, +}; pub use errors::Error; pub use indexmap::IndexSet; pub use new_pallet::{create_pallet_template, new_pallet_options::*, TemplatePalletConfig}; pub use new_parachain::instantiate_template_dir; +pub use relay::{clear_dmpq, RelayChain}; +// External export from subxt. +pub use subxt::{ + tx::{DynamicPayload, Payload}, + OnlineClient, SubstrateConfig, +}; pub use templates::{Config, Parachain, Provider}; pub use up::Zombienet; pub use utils::helpers::is_initial_endowment_valid; diff --git a/crates/pop-parachains/src/new_parachain.rs b/crates/pop-parachains/src/new_parachain.rs index 8974cfede..f9e28e527 100644 --- a/crates/pop-parachains/src/new_parachain.rs +++ b/crates/pop-parachains/src/new_parachain.rs @@ -87,12 +87,7 @@ pub fn instantiate_openzeppelin_template( let source = temp_dir.path(); let tag = Git::clone_and_degit(template.repository_url()?, source, tag_version)?; - let mut template_name = template.template_name_without_provider(); - // Handle deprecated OpenZeppelin template - if matches!(template, Parachain::DeprecatedOpenZeppelinGeneric) { - template_name = Parachain::OpenZeppelinGeneric.template_name_without_provider(); - } - + let template_name = template.template_name_without_provider(); extract_template_files(template_name, temp_dir.path(), target, None)?; Ok(tag) } diff --git a/crates/pop-parachains/src/relay.rs b/crates/pop-parachains/src/relay.rs new file mode 100644 index 000000000..6ded8c497 --- /dev/null +++ b/crates/pop-parachains/src/relay.rs @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::{call, DynamicPayload, Error}; +use sp_core::twox_128; +use subxt::{ + config::BlockHash, + dynamic::{self, Value}, + ext::sp_core, + OnlineClient, PolkadotConfig, +}; + +/// Clears the DMPQ state for the given parachain IDs. +/// +/// # Arguments +/// * `client` - Client for the network which state is to be modified. +/// * `para_ids` - List of ids to build the keys that will be mutated. +pub async fn clear_dmpq( + client: OnlineClient, + para_ids: &[u32], +) -> Result { + // Wait for blocks to be produced. + let mut sub = client.blocks().subscribe_finalized().await?; + for _ in 0..2 { + sub.next().await; + } + + // Generate storage keys to be removed + let clear_dmq_keys = generate_storage_keys(para_ids); + + // Submit calls to remove specified keys + let kill_storage = construct_kill_storage_call(clear_dmq_keys); + let sudo = subxt_signer::sr25519::dev::alice(); + let sudo_call = call::construct_sudo_extrinsic(kill_storage); + Ok(client.tx().sign_and_submit_default(&sudo_call, &sudo).await?) +} + +fn construct_kill_storage_call(keys: Vec>) -> DynamicPayload { + dynamic::tx( + "System", + "kill_storage", + vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], + ) +} + +fn generate_storage_keys(para_ids: &[u32]) -> Vec> { + let dmp = twox_128("Dmp".as_bytes()); + let dmp_queue_heads = twox_128("DownwardMessageQueueHeads".as_bytes()); + let dmp_queues = twox_128("DownwardMessageQueues".as_bytes()); + let mut clear_dmq_keys = Vec::>::new(); + for id in para_ids { + let id = id.to_le_bytes(); + // DMP Queue Head + let mut key = dmp.to_vec(); + key.extend(&dmp_queue_heads); + key.extend(sp_core::twox_64(&id)); + key.extend(id); + clear_dmq_keys.push(key); + // DMP Queue + let mut key = dmp.to_vec(); + key.extend(&dmp_queues); + key.extend(sp_core::twox_64(&id)); + key.extend(id); + clear_dmq_keys.push(key); + } + clear_dmq_keys +} + +/// A supported relay chain. +#[derive(Debug, PartialEq)] +pub enum RelayChain { + /// Paseo. + PaseoLocal, + /// Westend. + WestendLocal, +} + +impl RelayChain { + /// Attempts to convert a chain identifier into a supported `RelayChain` variant. + /// + /// # Arguments + /// * `id` - The relay chain identifier. + pub fn from(id: &str) -> Option { + match id { + "paseo-local" => Some(RelayChain::PaseoLocal), + "westend-local" => Some(RelayChain::WestendLocal), + _ => None, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use subxt::ext::sp_core::twox_64; + use RelayChain::*; + + #[test] + fn construct_kill_storage_call_works() { + let keys = vec!["key".as_bytes().to_vec()]; + assert_eq!( + construct_kill_storage_call(keys.clone()), + dynamic::tx( + "System", + "kill_storage", + vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], + ) + ) + } + + #[test] + fn generate_storage_keys_works() { + let para_ids = vec![1_000, 4_385]; + let dmp = twox_128("Dmp".as_bytes()); + let dmp_queue_heads = [dmp, twox_128("DownwardMessageQueueHeads".as_bytes())].concat(); + let dmp_queues = [dmp, twox_128("DownwardMessageQueues".as_bytes())].concat(); + + assert_eq!( + generate_storage_keys(¶_ids), + para_ids + .iter() + .flat_map(|id| { + let id = id.to_le_bytes().to_vec(); + [ + // DMP Queue Head + [dmp_queue_heads.clone(), twox_64(&id).to_vec(), id.clone()].concat(), + // DMP Queue + [dmp_queues.clone(), twox_64(&id).to_vec(), id].concat(), + ] + }) + .collect::>() + ) + } + + #[test] + fn supported_relay_chains() { + for (s, e) in [ + // Only chains with sudo supported + ("paseo-local", Some(PaseoLocal)), + ("westend-local", Some(WestendLocal)), + ("kusama-local", None), + ("polkadot-local", None), + ] { + assert_eq!(RelayChain::from(s), e) + } + } +} diff --git a/crates/pop-parachains/src/templates.rs b/crates/pop-parachains/src/templates.rs index 0f9ba5794..324f6f23f 100644 --- a/crates/pop-parachains/src/templates.rs +++ b/crates/pop-parachains/src/templates.rs @@ -177,23 +177,6 @@ pub enum Parachain { ) )] ParityFPT, - // OpenZeppelin - #[strum( - serialize = "polkadot-generic-runtime-template", - message = "Generic Runtime Template", - detailed_message = "A generic template for Substrate Runtime.", - props( - Provider = "OpenZeppelin", - Repository = "https://github.com/OpenZeppelin/polkadot-runtime-templates", - Network = "./zombienet-config/devnet.toml", - SupportedVersions = "v1.0.0,v2.0.1", - IsAudited = "true", - License = "GPL-3.0", - IsDeprecated = "true", - DeprecatedMessage = "This template is deprecated. Please use openzeppelin/generic-template in the future.", - ) - )] - DeprecatedOpenZeppelinGeneric, // templates for unit tests below #[cfg(test)] #[strum( @@ -273,7 +256,6 @@ mod tests { // openzeppelin ("openzeppelin/generic-template".to_string(), OpenZeppelinGeneric), ("openzeppelin/evm-template".to_string(), OpenZeppelinEVM), - ("polkadot-generic-runtime-template".to_string(), DeprecatedOpenZeppelinGeneric), ("cpt".to_string(), ParityContracts), ("fpt".to_string(), ParityFPT), ("test_01".to_string(), TestTemplate01), @@ -289,7 +271,6 @@ mod tests { (EVM, "evm".to_string()), (OpenZeppelinGeneric, "generic-template".to_string()), (OpenZeppelinEVM, "evm-template".to_string()), - (DeprecatedOpenZeppelinGeneric, "polkadot-generic-runtime-template".to_string()), (ParityContracts, "cpt".to_string()), (ParityFPT, "fpt".to_string()), (TestTemplate01, "test_01".to_string()), @@ -331,7 +312,6 @@ mod tests { (EVM, Some("./network.toml")), (OpenZeppelinGeneric, Some("./zombienet-config/devnet.toml")), (OpenZeppelinEVM, Some("./zombienet-config/devnet.toml")), - (DeprecatedOpenZeppelinGeneric, Some("./zombienet-config/devnet.toml")), (ParityContracts, Some("./zombienet.toml")), (ParityFPT, Some("./zombienet-config.toml")), (TestTemplate01, Some("")), @@ -348,7 +328,6 @@ mod tests { (EVM, Some("Unlicense")), (OpenZeppelinGeneric, Some("GPL-3.0")), (OpenZeppelinEVM, Some("GPL-3.0")), - (DeprecatedOpenZeppelinGeneric, Some("GPL-3.0")), (ParityContracts, Some("Unlicense")), (ParityFPT, Some("Unlicense")), (TestTemplate01, Some("Unlicense")), diff --git a/crates/pop-parachains/src/up/chain_specs.rs b/crates/pop-parachains/src/up/chain_specs.rs index 3513a587e..e81db7ee9 100644 --- a/crates/pop-parachains/src/up/chain_specs.rs +++ b/crates/pop-parachains/src/up/chain_specs.rs @@ -22,7 +22,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/polkadot-runtimes", Binary = "chain-spec-generator", Chain = "kusama-local", - Fallback = "v1.2.7" + Fallback = "v1.3.3" ))] Kusama, /// Paseo. @@ -30,7 +30,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/paseo-runtimes", Binary = "chain-spec-generator", Chain = "paseo-local", - Fallback = "v1.2.6" + Fallback = "v1.3.4" ))] Paseo, /// Polkadot. @@ -38,7 +38,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/polkadot-runtimes", Binary = "chain-spec-generator", Chain = "polkadot-local", - Fallback = "v1.2.7" + Fallback = "v1.3.3" ))] Polkadot, } @@ -111,7 +111,7 @@ mod tests { #[tokio::test] async fn kusama_works() -> anyhow::Result<()> { let expected = Runtime::Kusama; - let version = "v1.2.7"; + let version = "v1.3.3"; let temp_dir = tempdir()?; let binary = chain_spec_generator("kusama-local", Some(version), temp_dir.path()) .await? @@ -135,7 +135,7 @@ mod tests { #[tokio::test] async fn paseo_works() -> anyhow::Result<()> { let expected = Runtime::Paseo; - let version = "v1.2.4"; + let version = "v1.3.4"; let temp_dir = tempdir()?; let binary = chain_spec_generator("paseo-local", Some(version), temp_dir.path()) .await? @@ -159,7 +159,7 @@ mod tests { #[tokio::test] async fn polkadot_works() -> anyhow::Result<()> { let expected = Runtime::Polkadot; - let version = "v1.2.7"; + let version = "v1.3.3"; let temp_dir = tempdir()?; let binary = chain_spec_generator("polkadot-local", Some(version), temp_dir.path()) .await? diff --git a/crates/pop-parachains/src/up/mod.rs b/crates/pop-parachains/src/up/mod.rs index 036ae889d..abefa8051 100644 --- a/crates/pop-parachains/src/up/mod.rs +++ b/crates/pop-parachains/src/up/mod.rs @@ -30,6 +30,8 @@ pub struct Zombienet { relay_chain: RelayChain, /// The configuration required to launch parachains. parachains: IndexMap, + /// Whether any HRMP channels are to be pre-opened. + hrmp_channels: bool, } impl Zombienet { @@ -59,7 +61,7 @@ impl Zombienet { // Parse network config let network_config = NetworkConfiguration::from(network_config)?; // Determine relay and parachain requirements based on arguments and config - let relay_chain = Self::relay_chain( + let relay_chain = Self::init_relay_chain( relay_chain_version, relay_chain_runtime_version, &network_config, @@ -84,7 +86,9 @@ impl Zombienet { cache, ) .await?; - Ok(Self { network_config, relay_chain, parachains }) + let hrmp_channels = + network_config.hrmp_channels().map(|c| !c.is_empty()).unwrap_or_default(); + Ok(Self { network_config, relay_chain, parachains, hrmp_channels }) } /// The binaries required to launch the network. @@ -216,7 +220,7 @@ impl Zombienet { /// will use the latest available version). /// * `network_config` - The network configuration to be used to launch a network. /// * `cache` - The location used for caching binaries. - async fn relay_chain( + async fn init_relay_chain( version: Option<&str>, runtime_version: Option<&str>, network_config: &NetworkConfiguration, @@ -276,6 +280,16 @@ impl Zombienet { Ok(relay::default(version, runtime_version, chain, cache).await?) } + /// The name of the relay chain. + pub fn relay_chain(&self) -> &str { + &self.relay_chain.chain + } + + /// Whether any HRMP channels are to be pre-opened. + pub fn hrmp_channels(&self) -> bool { + self.hrmp_channels + } + /// Launches the local network. pub async fn spawn(&mut self) -> Result, Error> { // Symlink polkadot workers @@ -354,6 +368,11 @@ impl NetworkConfiguration { self.0.get_mut("parachains").and_then(|p| p.as_array_of_tables_mut()) } + /// Returns the `hrmp_channels` configuration. + fn hrmp_channels(&self) -> Option<&ArrayOfTables> { + self.0.get("hrmp_channels").and_then(|p| p.as_array_of_tables()) + } + /// Returns the `command` configuration. fn command(config: &Table) -> Option<&Item> { config.get("command") @@ -660,6 +679,8 @@ mod tests { use std::{env::current_dir, fs::File, io::Write}; use tempfile::tempdir; + pub(crate) const VERSION: &str = "stable2409"; + mod zombienet { use super::*; use pop_common::Status; @@ -683,12 +704,11 @@ mod tests { chain = "paseo-local" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -698,14 +718,16 @@ chain = "paseo-local" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); + assert_eq!(zombienet.relay_chain(), "paseo-local"); + assert!(!zombienet.hrmp_channels()); Ok(()) } @@ -721,7 +743,7 @@ chain = "paseo-local" chain = "paseo-local" "# )?; - let version = "v1.2.7"; + let version = "v1.3.3"; let zombienet = Zombienet::new( &cache, @@ -761,15 +783,14 @@ chain = "paseo-local" r#" [relaychain] chain = "paseo-local" -default_command = "./bin-v1.6.0/polkadot" +default_command = "./bin-stable2409/polkadot" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -779,12 +800,12 @@ default_command = "./bin-v1.6.0/polkadot" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); Ok(()) @@ -807,12 +828,11 @@ validator = true command = "polkadot" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -822,12 +842,12 @@ command = "polkadot" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); Ok(()) @@ -852,14 +872,14 @@ command = "polkadot" [[relaychain.nodes]] name = "bob" validator = true -command = "polkadot-v1.12.0" +command = "polkadot-stable2409" "# )?; assert!(matches!( Zombienet::new(&cache, config.path().to_str().unwrap(), None, None, None, None, None).await, Err(Error::UnsupportedCommand(error)) - if error == "the relay chain command is unsupported: polkadot-v1.12.0" + if error == "the relay chain command is unsupported: polkadot-stable2409" )); Ok(()) } @@ -879,14 +899,14 @@ default_command = "polkadot" [[relaychain.nodes]] name = "alice" validator = true -command = "polkadot-v1.12.0" +command = "polkadot-stable2409" "# )?; assert!(matches!( Zombienet::new(&cache, config.path().to_str().unwrap(), None, None, None, None, None).await, Err(Error::UnsupportedCommand(error)) - if error == "the relay chain command is unsupported: polkadot-v1.12.0" + if error == "the relay chain command is unsupported: polkadot-stable2409" )); Ok(()) } @@ -907,12 +927,12 @@ id = 1000 chain = "asset-hub-paseo-local" "# )?; - let system_parachain_version = "v1.12.0"; + let system_parachain_version = "stable2407"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some("v1.11.0"), + Some(VERSION), None, Some(system_parachain_version), None, @@ -952,7 +972,6 @@ id = 1000 chain = "asset-hub-paseo-local" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, @@ -960,7 +979,7 @@ chain = "asset-hub-paseo-local" None, None, None, - Some(version), + Some(VERSION), None, ) .await?; @@ -972,13 +991,13 @@ chain = "asset-hub-paseo-local" assert_eq!(chain_spec_generator.name(), "paseo-chain-spec-generator"); assert_eq!( chain_spec_generator.path(), - temp_dir.path().join(format!("paseo-chain-spec-generator-{version}")) + temp_dir.path().join(format!("paseo-chain-spec-generator-{VERSION}")) ); - assert_eq!(chain_spec_generator.version().unwrap(), version); + assert_eq!(chain_spec_generator.version().unwrap(), VERSION); assert!(matches!( chain_spec_generator, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); Ok(()) } @@ -1186,6 +1205,48 @@ default_command = "moonbeam" Ok(()) } + #[tokio::test] + async fn new_with_hrmp_channels_works() -> Result<()> { + let temp_dir = tempdir()?; + let cache = PathBuf::from(temp_dir.path()); + let config = Builder::new().suffix(".toml").tempfile()?; + writeln!( + config.as_file(), + r#" +[relaychain] +chain = "paseo-local" + +[[parachains]] +id = 1000 +chain = "asset-hub-paseo-local" + +[[parachains]] +id = 4385 +default_command = "pop-node" + +[[hrmp_channels]] +sender = 4385 +recipient = 1000 +max_capacity = 1000 +max_message_size = 8000 +"# + )?; + + let zombienet = Zombienet::new( + &cache, + config.path().to_str().unwrap(), + None, + None, + None, + None, + None, + ) + .await?; + + assert!(zombienet.hrmp_channels()); + Ok(()) + } + #[tokio::test] async fn new_ensures_parachain_id_exists() -> Result<()> { let temp_dir = tempdir()?; @@ -1384,10 +1445,9 @@ chain = "paseo-local" chain = "paseo-local" "# )?; - let version = "v1.12.0"; - File::create(cache.join(format!("polkadot-{version}")))?; - File::create(cache.join(format!("polkadot-execute-worker-{version}")))?; - File::create(cache.join(format!("polkadot-prepare-worker-{version}")))?; + File::create(cache.join(format!("polkadot-{VERSION}")))?; + File::create(cache.join(format!("polkadot-execute-worker-{VERSION}")))?; + File::create(cache.join(format!("polkadot-prepare-worker-{VERSION}")))?; let mut zombienet = Zombienet::new( &cache, diff --git a/crates/pop-parachains/src/up/parachains.rs b/crates/pop-parachains/src/up/parachains.rs index 06eda16e6..ad6075454 100644 --- a/crates/pop-parachains/src/up/parachains.rs +++ b/crates/pop-parachains/src/up/parachains.rs @@ -22,7 +22,7 @@ pub(super) enum Parachain { Repository = "https://github.com/r0gue-io/polkadot", Binary = "polkadot-parachain", TagFormat = "polkadot-{tag}", - Fallback = "v1.12.0" + Fallback = "stable2409" ))] System, /// Pop Network makes it easy for smart contract developers to use the power of Polkadot. @@ -30,7 +30,7 @@ pub(super) enum Parachain { Repository = "https://github.com/r0gue-io/pop-node", Binary = "pop-node", Prerelease = "false", - Fallback = "testnet-v0.4.1" + Fallback = "testnet-v0.4.2" ))] Pop, } @@ -148,7 +148,7 @@ pub(super) async fn from( #[cfg(test)] mod tests { - use super::*; + use super::{super::tests::VERSION, *}; use std::path::PathBuf; use tempfile::tempdir; @@ -159,7 +159,7 @@ mod tests { "polkadot", None, None, - "v1.12.0", + VERSION, Some("asset-hub-paseo-local"), tempdir()?.path() ) @@ -170,13 +170,12 @@ mod tests { #[tokio::test] async fn system_using_relay_version() -> anyhow::Result<()> { - let version = "v1.12.0"; let expected = Parachain::System; let para_id = 1000; let temp_dir = tempdir()?; let parachain = - system(para_id, expected.binary(), None, None, version, None, temp_dir.path()) + system(para_id, expected.binary(), None, None, VERSION, None, temp_dir.path()) .await? .unwrap(); assert_eq!(para_id, parachain.id); @@ -184,7 +183,7 @@ mod tests { if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: vec![(expected.binary(), None)], @@ -196,13 +195,12 @@ mod tests { #[tokio::test] async fn system_works() -> anyhow::Result<()> { - let version = "v1.12.0"; let expected = Parachain::System; let para_id = 1000; let temp_dir = tempdir()?; let parachain = - system(para_id, expected.binary(), Some(version), None, version, None, temp_dir.path()) + system(para_id, expected.binary(), Some(VERSION), None, VERSION, None, temp_dir.path()) .await? .unwrap(); assert_eq!(para_id, parachain.id); @@ -210,7 +208,7 @@ mod tests { if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: vec![(expected.binary(), None)], @@ -223,7 +221,7 @@ mod tests { #[tokio::test] async fn system_with_chain_spec_generator_works() -> anyhow::Result<()> { let expected = Parachain::System; - let runtime_version = "v1.2.7"; + let runtime_version = "v1.3.3"; let para_id = 1000; let temp_dir = tempdir()?; diff --git a/crates/pop-parachains/src/up/relay.rs b/crates/pop-parachains/src/up/relay.rs index 662e639fd..2390e446a 100644 --- a/crates/pop-parachains/src/up/relay.rs +++ b/crates/pop-parachains/src/up/relay.rs @@ -24,7 +24,7 @@ pub(super) enum RelayChain { Repository = "https://github.com/r0gue-io/polkadot", Binary = "polkadot", TagFormat = "polkadot-{tag}", - Fallback = "v1.12.0" + Fallback = "stable2409" ))] Polkadot, } @@ -131,17 +131,18 @@ mod tests { use super::*; use tempfile::tempdir; + const VERSION: &str = "stable2409"; + #[tokio::test] async fn default_works() -> anyhow::Result<()> { let expected = RelayChain::Polkadot; - let version = "v1.12.0"; let temp_dir = tempdir()?; - let relay = default(Some(version), None, None, temp_dir.path()).await?; + let relay = default(Some(VERSION), None, None, temp_dir.path()).await?; assert!(matches!(relay.binary, Binary::Source { name, source, cache } if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: ["polkadot", "polkadot-execute-worker", "polkadot-prepare-worker"].map(|b| (b, None)).to_vec(), @@ -154,7 +155,7 @@ mod tests { #[tokio::test] async fn default_with_chain_spec_generator_works() -> anyhow::Result<()> { - let runtime_version = "v1.2.7"; + let runtime_version = "v1.3.3"; let temp_dir = tempdir()?; let relay = default(None, Some(runtime_version), Some("paseo-local"), temp_dir.path()).await?; @@ -186,15 +187,14 @@ mod tests { #[tokio::test] async fn from_handles_local_command() -> anyhow::Result<()> { let expected = RelayChain::Polkadot; - let version = "v1.12.0"; let temp_dir = tempdir()?; let relay = - from("./bin-v1.6.0/polkadot", Some(version), None, None, temp_dir.path()).await?; + from("./bin-stable2409/polkadot", Some(VERSION), None, None, temp_dir.path()).await?; assert!(matches!(relay.binary, Binary::Source { name, source, cache } if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: ["polkadot", "polkadot-execute-worker", "polkadot-prepare-worker"].map(|b| (b, None)).to_vec(), diff --git a/crates/pop-parachains/src/utils/helpers.rs b/crates/pop-parachains/src/utils/helpers.rs index bd39eec9e..f38d7bce5 100644 --- a/crates/pop-parachains/src/utils/helpers.rs +++ b/crates/pop-parachains/src/utils/helpers.rs @@ -33,7 +33,8 @@ pub fn is_initial_endowment_valid(initial_endowment: &str) -> bool { initial_endowment.parse::().is_ok() || is_valid_bitwise_left_shift(initial_endowment).is_ok() } -// Auxiliar method to check if the endowment input with a shift left (1u64 << 60) format is valid. + +// Auxiliary method to check if the endowment input with a shift left (1u64 << 60) format is valid. // Parse the self << rhs format and check the shift left operation is valid. fn is_valid_bitwise_left_shift(initial_endowment: &str) -> Result { let v: Vec<&str> = initial_endowment.split(" << ").collect(); diff --git a/deny.toml b/deny.toml index 5c295de57..b1e67ce44 100644 --- a/deny.toml +++ b/deny.toml @@ -20,8 +20,10 @@ allow = [ "GPL-3.0", "MIT", "MPL-2.0", + "Unicode-3.0", "Unicode-DFS-2016", - "Unlicense" + "Unlicense", + "Zlib" ] confidence-threshold = 0.93 @@ -34,4 +36,4 @@ name = "ring" expression = "ISC AND MIT AND OpenSSL" license-files = [ { path = "LICENSE", hash = 0xbd0eed23 }, -] \ No newline at end of file +] diff --git a/tests/networks/kusama+asset-hub.toml b/tests/networks/kusama+asset-hub.toml new file mode 100644 index 000000000..c652bd841 --- /dev/null +++ b/tests/networks/kusama+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/kusama+asset-hub.toml + +[relaychain] +chain = "kusama-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-kusama-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/paseo+asset-hub.toml b/tests/networks/paseo+asset-hub.toml new file mode 100644 index 000000000..a75719376 --- /dev/null +++ b/tests/networks/paseo+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/paseo+asset-hub.toml + +[relaychain] +chain = "paseo-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-paseo-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/polkadot+asset-hub.toml b/tests/networks/polkadot+asset-hub.toml new file mode 100644 index 000000000..9cf6735b2 --- /dev/null +++ b/tests/networks/polkadot+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/polkadot+asset-hub.toml + +[relaychain] +chain = "polkadot-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-polkadot-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/pop.toml b/tests/networks/pop.toml index 9ad7c871d..643f1a0b5 100644 --- a/tests/networks/pop.toml +++ b/tests/networks/pop.toml @@ -24,4 +24,16 @@ default_command = "pop-node" [[parachains.collators]] name = "pop" -args = ["-lruntime::contracts=debug"] \ No newline at end of file +args = ["-lruntime::contracts=debug"] + +[[hrmp_channels]] +sender = 1000 +recipient = 4385 +max_capacity = 1000 +max_message_size = 5000 + +[[hrmp_channels]] +sender = 4385 +recipient = 1000 +max_capacity = 1000 +max_message_size = 8000 \ No newline at end of file diff --git a/tests/networks/westend+asset-hub.toml b/tests/networks/westend+asset-hub.toml new file mode 100644 index 000000000..3404173f8 --- /dev/null +++ b/tests/networks/westend+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/westend+asset-hub.toml + +[relaychain] +chain = "westend-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-westend-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/westend.toml b/tests/networks/westend.toml new file mode 100644 index 000000000..7bdb66bdd --- /dev/null +++ b/tests/networks/westend.toml @@ -0,0 +1,12 @@ +# pop up parachain -f ./tests/networks/westend.toml + +[relaychain] +chain = "westend-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true
(path: P, message: &str) -> Result where P: AsRef, { @@ -156,150 +157,6 @@ fn process_args( args } -// Formats a specified type, using the registry to output its full type representation. -fn format_type(ty: &Type, registry: &PortableRegistry) -> String { - let mut name = ty - .path - .segments - .last() - .map(|s| s.to_owned()) - .unwrap_or_else(|| ty.path.to_string()); - - if !ty.type_params.is_empty() { - let params: Vec<_> = ty - .type_params - .iter() - .filter_map(|p| registry.resolve(p.ty.unwrap().id)) - .map(|t| format_type(t, registry)) - .collect(); - name = format!("{name}<{}>", params.join(",")); - } - - name = format!( - "{name}{}", - match &ty.type_def { - TypeDef::Composite(composite) => { - if composite.fields.is_empty() { - return "".to_string(); - } - - let mut named = false; - let fields: Vec<_> = composite - .fields - .iter() - .filter_map(|f| match f.name.as_ref() { - None => registry.resolve(f.ty.id).map(|t| format_type(t, registry)), - Some(field) => { - named = true; - f.type_name.as_ref().map(|t| format!("{field}: {t}")) - }, - }) - .collect(); - match named { - true => format!(" {{ {} }}", fields.join(", ")), - false => format!(" ({})", fields.join(", ")), - } - }, - TypeDef::Variant(variant) => { - let variants: Vec<_> = variant - .variants - .iter() - .map(|v| { - if v.fields.is_empty() { - return v.name.clone(); - } - - let name = v.name.as_str(); - let mut named = false; - let fields: Vec<_> = v - .fields - .iter() - .filter_map(|f| match f.name.as_ref() { - None => registry.resolve(f.ty.id).map(|t| format_type(t, registry)), - Some(field) => { - named = true; - f.type_name.as_ref().map(|t| format!("{field}: {t}")) - }, - }) - .collect(); - format!( - "{name}{}", - match named { - true => format!("{{ {} }}", fields.join(", ")), - false => format!("({})", fields.join(", ")), - } - ) - }) - .collect(); - format!(": {}", variants.join(", ")) - }, - TypeDef::Sequence(sequence) => { - format!( - "[{}]", - format_type( - registry.resolve(sequence.type_param.id).expect("sequence type not found"), - registry - ) - ) - }, - TypeDef::Array(array) => { - format!( - "[{};{}]", - format_type( - registry.resolve(array.type_param.id).expect("array type not found"), - registry - ), - array.len - ) - }, - TypeDef::Tuple(tuple) => { - let fields: Vec<_> = tuple - .fields - .iter() - .filter_map(|p| registry.resolve(p.id)) - .map(|t| format_type(t, registry)) - .collect(); - format!("({})", fields.join(",")) - }, - TypeDef::Primitive(primitive) => { - use TypeDefPrimitive::*; - match primitive { - Bool => "bool", - Char => "char", - Str => "str", - U8 => "u8", - U16 => "u16", - U32 => "u32", - U64 => "u64", - U128 => "u128", - U256 => "u256", - I8 => "i8", - I16 => "i16", - I32 => "i32", - I64 => "i64", - I128 => "i128", - I256 => "i256", - } - .to_string() - }, - TypeDef::Compact(compact) => { - format!( - "Compact<{}>", - format_type( - registry.resolve(compact.type_param.id).expect("compact type not found"), - registry - ) - ) - }, - TypeDef::BitSequence(_) => { - unimplemented!("bit sequence not currently supported") - }, - } - ); - - name -} - /// Processes a list of argument values for a specified contract function, /// wrapping each value in `Some(...)` or replacing it with `None` if the argument is optional. /// diff --git a/crates/pop-contracts/src/utils/mod.rs b/crates/pop-contracts/src/utils/mod.rs index ad49e2dc6..a3a99323b 100644 --- a/crates/pop-contracts/src/utils/mod.rs +++ b/crates/pop-contracts/src/utils/mod.rs @@ -1,5 +1,149 @@ // SPDX-License-Identifier: GPL-3.0 -pub mod helpers; +use crate::errors::Error; +use contract_build::{util::decode_hex, ManifestPath}; +use contract_extrinsics::BalanceVariant; +use ink_env::{DefaultEnvironment, Environment}; +use pop_common::{Config, DefaultConfig}; +use sp_core::Bytes; +use std::{ + path::{Path, PathBuf}, + str::FromStr, +}; + pub mod metadata; -pub mod signer; + +/// Retrieves the manifest path for a contract project. +/// +/// # Arguments +/// * `path` - An optional path to the project directory. +pub fn get_manifest_path(path: Option<&Path>) -> Result { + if let Some(path) = path { + let full_path = PathBuf::from(path.to_string_lossy().to_string() + "/Cargo.toml"); + ManifestPath::try_from(Some(full_path)) + .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) + } else { + ManifestPath::try_from(path.as_ref()) + .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) + } +} + +/// Parses a balance value from a string representation. +/// +/// # Arguments +/// * `balance` - A string representing the balance value to parse. +pub fn parse_balance( + balance: &str, +) -> Result::Balance>, Error> { + BalanceVariant::from_str(balance).map_err(|e| Error::BalanceParsing(format!("{}", e))) +} + +/// Parses an account ID from its string representation. +/// +/// # Arguments +/// * `account` - A string representing the account ID to parse. +pub fn parse_account(account: &str) -> Result<::AccountId, Error> { + ::AccountId::from_str(account) + .map_err(|e| Error::AccountAddressParsing(format!("{}", e))) +} + +/// Parse hex encoded bytes. +/// +/// # Arguments +/// * `input` - A string containing hex-encoded bytes. +pub fn parse_hex_bytes(input: &str) -> Result { + let bytes = decode_hex(input).map_err(|e| Error::HexParsing(format!("{}", e)))?; + Ok(bytes.into()) +} + +/// Canonicalizes the given path to ensure consistency and resolve any symbolic links. +/// +/// # Arguments +/// * `target` - A reference to the `Path` to be canonicalized. +pub fn canonicalized_path(target: &Path) -> Result { + // Canonicalize the target path to ensure consistency and resolve any symbolic links. + target + .canonicalize() + // If an I/O error occurs during canonicalization, convert it into an Error enum variant. + .map_err(Error::IO) +} + +#[cfg(test)] +mod tests { + use super::*; + use anyhow::Result; + use std::fs; + + fn setup_test_environment() -> Result { + let temp_dir = tempfile::tempdir().expect("Could not create temp dir"); + let temp_contract_dir = temp_dir.path().join("test_contract"); + fs::create_dir(&temp_contract_dir)?; + crate::create_smart_contract( + "test_contract", + temp_contract_dir.as_path(), + &crate::Contract::Standard, + )?; + Ok(temp_dir) + } + + #[test] + fn test_get_manifest_path() -> Result<(), Error> { + let temp_dir = setup_test_environment()?; + get_manifest_path(Some(&PathBuf::from(temp_dir.path().join("test_contract"))))?; + Ok(()) + } + + #[test] + fn test_canonicalized_path() -> Result<(), Error> { + let temp_dir = tempfile::tempdir()?; + // Error case + let error_directory = canonicalized_path(&temp_dir.path().join("my_directory")); + assert!(error_directory.is_err()); + // Success case + canonicalized_path(temp_dir.path())?; + Ok(()) + } + + #[test] + fn parse_balance_works() -> Result<(), Error> { + let balance = parse_balance("100000")?; + assert_eq!(balance, BalanceVariant::Default(100000)); + Ok(()) + } + + #[test] + fn parse_balance_fails_wrong_balance() -> Result<(), Error> { + assert!(matches!(parse_balance("wrongbalance"), Err(super::Error::BalanceParsing(..)))); + Ok(()) + } + + #[test] + fn parse_account_works() -> Result<(), Error> { + let account = parse_account("5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A")?; + assert_eq!(account.to_string(), "5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A"); + Ok(()) + } + + #[test] + fn parse_account_fails_wrong_value() -> Result<(), Error> { + assert!(matches!( + parse_account("wrongaccount"), + Err(super::Error::AccountAddressParsing(..)) + )); + Ok(()) + } + + #[test] + fn parse_hex_bytes_works() -> Result<(), Error> { + let input_in_hex = "48656c6c6f"; + let result = parse_hex_bytes(input_in_hex)?; + assert_eq!(result, Bytes(vec![72, 101, 108, 108, 111])); + Ok(()) + } + + #[test] + fn parse_hex_bytes_fails_wrong_input() -> Result<()> { + assert!(matches!(parse_hex_bytes("wronghexvalue"), Err(Error::HexParsing(..)))); + Ok(()) + } +} diff --git a/crates/pop-contracts/tests/files/testing.wasm b/crates/pop-contracts/tests/files/testing.wasm index 430888669..e69de29bb 100644 Binary files a/crates/pop-contracts/tests/files/testing.wasm and b/crates/pop-contracts/tests/files/testing.wasm differ diff --git a/crates/pop-parachains/Cargo.toml b/crates/pop-parachains/Cargo.toml index dd6406824..619b3336e 100644 --- a/crates/pop-parachains/Cargo.toml +++ b/crates/pop-parachains/Cargo.toml @@ -12,12 +12,12 @@ version.workspace = true anyhow.workspace = true clap.workspace = true duct.workspace = true -flate2.workspace = true glob.workspace = true serde_json.workspace = true strum.workspace = true strum_macros.workspace = true -tar.workspace = true +subxt-signer.workspace = true +subxt.workspace = true tempfile.workspace = true thiserror.workspace = true tokio.workspace = true @@ -25,7 +25,9 @@ url.workspace = true askama.workspace = true indexmap.workspace = true -reqwest.workspace = true +scale-info.workspace = true +scale-value.workspace = true +sp-core.workspace = true symlink.workspace = true toml_edit.workspace = true walkdir.workspace = true @@ -33,8 +35,8 @@ walkdir.workspace = true zombienet-sdk.workspace = true # Pop -pop-common = { path = "../pop-common", version = "0.5.0" } +pop-common = { path = "../pop-common", version = "0.6.0" } [dev-dependencies] -mockito.workspace = true +# Used in doc tests. tokio-test.workspace = true diff --git a/crates/pop-parachains/src/call/metadata/action.rs b/crates/pop-parachains/src/call/metadata/action.rs new file mode 100644 index 000000000..1e8298fc7 --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/action.rs @@ -0,0 +1,211 @@ +// SPDX-License-Identifier: GPL-3.0 + +use super::{find_dispatchable_by_name, Pallet}; +use strum::{EnumMessage as _, EnumProperty as _, VariantArray as _}; +use strum_macros::{AsRefStr, Display, EnumMessage, EnumProperty, EnumString, VariantArray}; + +/// Enum representing various predefined actions supported. +#[derive( + AsRefStr, + Clone, + Debug, + Display, + EnumMessage, + EnumString, + EnumProperty, + Eq, + Hash, + PartialEq, + VariantArray, +)] +pub enum Action { + /// Transfer balance. + #[strum( + serialize = "transfer", + message = "transfer_allow_death", + detailed_message = "Transfer balance", + props(Pallet = "Balances") + )] + Transfer, + /// Create an asset. + #[strum( + serialize = "create", + message = "create", + detailed_message = "Create an asset", + props(Pallet = "Assets") + )] + CreateAsset, + /// Mint an asset. + #[strum( + serialize = "mint", + message = "mint", + detailed_message = "Mint an asset", + props(Pallet = "Assets") + )] + MintAsset, + /// Create a NFT collection. + #[strum( + serialize = "create_nft", + message = "create", + detailed_message = "Create a NFT collection", + props(Pallet = "Nfts") + )] + CreateCollection, + /// Mint a NFT. + #[strum( + serialize = "mint_nft", + message = "mint", + detailed_message = "Mint a NFT", + props(Pallet = "Nfts") + )] + MintNFT, + /// Purchase on-demand coretime. + #[strum( + serialize = "place_order_allow_death", + message = "place_order_allow_death", + detailed_message = "Purchase on-demand coretime", + props(Pallet = "OnDemand") + )] + PurchaseOnDemandCoretime, + /// Reserve a parachain ID. + #[strum( + serialize = "reserve", + message = "reserve", + detailed_message = "Reserve a parachain ID", + props(Pallet = "Registrar") + )] + Reserve, + /// Register a parachain ID with genesis state and code. + #[strum( + serialize = "register", + message = "register", + detailed_message = "Register a parachain ID with genesis state and code", + props(Pallet = "Registrar") + )] + Register, + /// Make a remark. + #[strum( + serialize = "remark", + message = "remark_with_event", + detailed_message = "Make a remark", + props(Pallet = "System") + )] + Remark, +} + +impl Action { + /// Get the description of the action. + pub fn description(&self) -> &str { + self.get_detailed_message().unwrap_or_default() + } + + /// Get the dispatchable function name corresponding to the action. + pub fn function_name(&self) -> &str { + self.get_message().unwrap_or_default() + } + + /// Get the associated pallet name for the action. + pub fn pallet_name(&self) -> &str { + self.get_str("Pallet").unwrap_or_default() + } +} + +/// Fetch the list of supported actions based on available pallets. +/// +/// # Arguments +/// * `pallets`: Supported pallets. +pub fn supported_actions(pallets: &[Pallet]) -> Vec { + let mut actions = Vec::new(); + for action in Action::VARIANTS.iter() { + if find_dispatchable_by_name(pallets, action.pallet_name(), action.function_name()).is_ok() + { + actions.push(action.clone()); + } + } + actions +} + +#[cfg(test)] +mod tests { + use super::{Action::*, *}; + use crate::{call::tests::POP_NETWORK_TESTNET_URL, parse_chain_metadata, set_up_client}; + use anyhow::Result; + use std::collections::HashMap; + + const POLKADOT_NETWORK_URL: &str = "wss://polkadot-rpc.publicnode.com"; + + #[test] + fn action_descriptions_are_correct() { + let descriptions = HashMap::from([ + (CreateAsset, "Create an asset"), + (MintAsset, "Mint an asset"), + (CreateCollection, "Create a NFT collection"), + (MintNFT, "Mint a NFT"), + (PurchaseOnDemandCoretime, "Purchase on-demand coretime"), + (Transfer, "Transfer balance"), + (Register, "Register a parachain ID with genesis state and code"), + (Reserve, "Reserve a parachain ID"), + (Remark, "Make a remark"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.description(), descriptions.get(action).unwrap()); + } + } + + #[test] + fn pallet_names_are_correct() { + let pallets = HashMap::from([ + (CreateAsset, "Assets"), + (MintAsset, "Assets"), + (CreateCollection, "Nfts"), + (MintNFT, "Nfts"), + (PurchaseOnDemandCoretime, "OnDemand"), + (Transfer, "Balances"), + (Register, "Registrar"), + (Reserve, "Registrar"), + (Remark, "System"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.pallet_name(), pallets.get(action).unwrap(),); + } + } + + #[test] + fn function_names_are_correct() { + let pallets = HashMap::from([ + (CreateAsset, "create"), + (MintAsset, "mint"), + (CreateCollection, "create"), + (MintNFT, "mint"), + (PurchaseOnDemandCoretime, "place_order_allow_death"), + (Transfer, "transfer_allow_death"), + (Register, "register"), + (Reserve, "reserve"), + (Remark, "remark_with_event"), + ]); + + for action in Action::VARIANTS.iter() { + assert_eq!(&action.function_name(), pallets.get(action).unwrap(),); + } + } + + #[tokio::test] + async fn supported_actions_works() -> Result<()> { + // Test Pop Parachain. + let mut client: subxt::OnlineClient = + set_up_client(POP_NETWORK_TESTNET_URL).await?; + let actions = supported_actions(&parse_chain_metadata(&client)?); + assert_eq!( + actions, + vec![Transfer, CreateAsset, MintAsset, CreateCollection, MintNFT, Remark] + ); + + // Test Polkadot Relay Chain. + client = set_up_client(POLKADOT_NETWORK_URL).await?; + let actions = supported_actions(&parse_chain_metadata(&client)?); + assert_eq!(actions, vec![Transfer, PurchaseOnDemandCoretime, Reserve, Register, Remark]); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/metadata/mod.rs b/crates/pop-parachains/src/call/metadata/mod.rs new file mode 100644 index 000000000..5a9a9a2cb --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/mod.rs @@ -0,0 +1,335 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::errors::Error; +use params::Param; +use scale_value::stringify::custom_parsers; +use std::fmt::{Display, Formatter}; +use subxt::{dynamic::Value, utils::to_hex, Metadata, OnlineClient, SubstrateConfig}; + +pub mod action; +pub mod params; + +/// Represents a pallet in the blockchain, including its dispatchable functions. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Pallet { + /// The name of the pallet. + pub name: String, + /// The index of the pallet within the runtime. + pub index: u8, + /// The documentation of the pallet. + pub docs: String, + /// The dispatchable functions of the pallet. + pub functions: Vec, +} + +impl Display for Pallet { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name) + } +} + +/// Represents a dispatchable function. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Function { + /// The pallet containing the dispatchable function. + pub pallet: String, + /// The name of the function. + pub name: String, + /// The index of the function within the pallet. + pub index: u8, + /// The documentation of the function. + pub docs: String, + /// The parameters of the function. + pub params: Vec, + /// Whether this function is supported (no recursive or unsupported types like `RuntimeCall`). + pub is_supported: bool, +} + +impl Display for Function { + fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { + write!(f, "{}", self.name) + } +} + +/// Parses the chain metadata to extract information about pallets and their dispatchable functions. +/// +/// # Arguments +/// * `client`: The client to interact with the chain. +/// +/// NOTE: pallets are ordered by their index within the runtime by default. +pub fn parse_chain_metadata(client: &OnlineClient) -> Result, Error> { + let metadata: Metadata = client.metadata(); + + let pallets = metadata + .pallets() + .map(|pallet| { + let functions = pallet + .call_variants() + .map(|variants| { + variants + .iter() + .map(|variant| { + let mut is_supported = true; + + // Parse parameters for the dispatchable function. + let params = { + let mut parsed_params = Vec::new(); + for field in &variant.fields { + match params::field_to_param(&metadata, field) { + Ok(param) => parsed_params.push(param), + Err(_) => { + // If an error occurs while parsing the values, mark the + // dispatchable function as unsupported rather than + // error. + is_supported = false; + parsed_params.clear(); + break; + }, + } + } + parsed_params + }; + + Ok(Function { + pallet: pallet.name().to_string(), + name: variant.name.clone(), + index: variant.index, + docs: if is_supported { + // Filter out blank lines and then flatten into a single value. + variant + .docs + .iter() + .filter(|l| !l.is_empty()) + .cloned() + .collect::>() + .join(" ") + } else { + // To display the message in the UI + "Function Not Supported".to_string() + }, + params, + is_supported, + }) + }) + .collect::, Error>>() + }) + .unwrap_or_else(|| Ok(vec![]))?; + + Ok(Pallet { + name: pallet.name().to_string(), + index: pallet.index(), + docs: pallet.docs().join(" "), + functions, + }) + }) + .collect::, Error>>()?; + + Ok(pallets) +} + +/// Finds a specific pallet by name and retrieves its details from metadata. +/// +/// # Arguments +/// * `pallets`: List of pallets available within the chain's runtime. +/// * `pallet_name`: The name of the pallet to find. +pub fn find_pallet_by_name<'a>( + pallets: &'a [Pallet], + pallet_name: &str, +) -> Result<&'a Pallet, Error> { + if let Some(pallet) = pallets.iter().find(|p| p.name == pallet_name) { + Ok(pallet) + } else { + Err(Error::PalletNotFound(pallet_name.to_string())) + } +} + +/// Finds a specific dispatchable function by name and retrieves its details from metadata. +/// +/// # Arguments +/// * `pallets`: List of pallets available within the chain's runtime. +/// * `pallet_name`: The name of the pallet. +/// * `function_name`: Name of the dispatchable function to locate. +pub fn find_dispatchable_by_name<'a>( + pallets: &'a [Pallet], + pallet_name: &str, + function_name: &str, +) -> Result<&'a Function, Error> { + let pallet = find_pallet_by_name(pallets, pallet_name)?; + if let Some(function) = pallet.functions.iter().find(|&e| e.name == function_name) { + Ok(function) + } else { + Err(Error::FunctionNotSupported) + } +} + +/// Parses and processes raw string parameter values for a dispatchable function, mapping them to +/// `Value` types. +/// +/// # Arguments +/// * `params`: The metadata definition for each parameter of the corresponding dispatchable +/// function. +/// * `raw_params`: A vector of raw string arguments for the dispatchable function. +pub fn parse_dispatchable_arguments( + params: &[Param], + raw_params: Vec, +) -> Result, Error> { + params + .iter() + .zip(raw_params) + .map(|(param, raw_param)| { + // Convert sequence parameters to hex if is_sequence + let processed_param = if param.is_sequence && !raw_param.starts_with("0x") { + to_hex(&raw_param) + } else { + raw_param + }; + scale_value::stringify::from_str_custom() + .add_custom_parser(custom_parsers::parse_hex) + .add_custom_parser(custom_parsers::parse_ss58) + .parse(&processed_param) + .0 + .map_err(|_| Error::ParamProcessingError) + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + use crate::{call::tests::POP_NETWORK_TESTNET_URL, set_up_client}; + use anyhow::Result; + use sp_core::bytes::from_hex; + use subxt::ext::scale_bits; + + #[tokio::test] + async fn parse_chain_metadata_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + // Test the first pallet is parsed correctly + let first_pallet = pallets.first().unwrap(); + assert_eq!(first_pallet.name, "System"); + assert_eq!(first_pallet.index, 0); + assert_eq!(first_pallet.docs, ""); + assert_eq!(first_pallet.functions.len(), 11); + let first_function = first_pallet.functions.first().unwrap(); + assert_eq!(first_function.name, "remark"); + assert_eq!(first_function.index, 0); + assert_eq!( + first_function.docs, + "Make some on-chain remark. Can be executed by every `origin`." + ); + assert!(first_function.is_supported); + assert_eq!(first_function.params.first().unwrap().name, "remark"); + assert_eq!(first_function.params.first().unwrap().type_name, "[u8]"); + assert_eq!(first_function.params.first().unwrap().sub_params.len(), 0); + assert!(!first_function.params.first().unwrap().is_optional); + assert!(!first_function.params.first().unwrap().is_tuple); + assert!(!first_function.params.first().unwrap().is_variant); + assert!(first_function.params.first().unwrap().is_sequence); + Ok(()) + } + + #[tokio::test] + async fn find_pallet_by_name_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + assert!(matches!( + find_pallet_by_name(&pallets, "WrongName"), + Err(Error::PalletNotFound(pallet)) if pallet == "WrongName".to_string())); + let pallet = find_pallet_by_name(&pallets, "Balances")?; + assert_eq!(pallet.name, "Balances"); + assert_eq!(pallet.functions.len(), 9); + Ok(()) + } + + #[tokio::test] + async fn find_dispatchable_by_name_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + assert!(matches!( + find_dispatchable_by_name(&pallets, "WrongName", "wrong_name"), + Err(Error::PalletNotFound(pallet)) if pallet == "WrongName".to_string())); + assert!(matches!( + find_dispatchable_by_name(&pallets, "Balances", "wrong_name"), + Err(Error::FunctionNotSupported) + )); + let function = find_dispatchable_by_name(&pallets, "Balances", "force_transfer")?; + assert_eq!(function.name, "force_transfer"); + assert_eq!(function.docs, "Exactly as `transfer_allow_death`, except the origin must be root and the source account may be specified."); + assert_eq!(function.is_supported, true); + assert_eq!(function.params.len(), 3); + Ok(()) + } + + #[test] + fn parse_dispatchable_arguments_works() -> Result<()> { + // Values for testing from: https://docs.rs/scale-value/0.18.0/scale_value/stringify/fn.from_str.html + // and https://docs.rs/scale-value/0.18.0/scale_value/stringify/fn.from_str_custom.html + let args = [ + "1".to_string(), + "-1".to_string(), + "true".to_string(), + "'a'".to_string(), + "\"hi\"".to_string(), + "{ a: true, b: \"hello\" }".to_string(), + "MyVariant { a: true, b: \"hello\" }".to_string(), + "<0101>".to_string(), + "(1,2,0x030405)".to_string(), + r#"{ + name: "Alice", + address: 5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty + }"# + .to_string(), + ] + .to_vec(); + let addr: Vec<_> = + from_hex("8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48") + .unwrap() + .into_iter() + .map(|b| Value::u128(b as u128)) + .collect(); + // Define mock dispatchable function parameters for testing. + let params = vec![ + Param { type_name: "u128".to_string(), ..Default::default() }, + Param { type_name: "i128".to_string(), ..Default::default() }, + Param { type_name: "bool".to_string(), ..Default::default() }, + Param { type_name: "char".to_string(), ..Default::default() }, + Param { type_name: "string".to_string(), ..Default::default() }, + Param { type_name: "compostie".to_string(), ..Default::default() }, + Param { type_name: "variant".to_string(), is_variant: true, ..Default::default() }, + Param { type_name: "bit_sequence".to_string(), ..Default::default() }, + Param { type_name: "tuple".to_string(), is_tuple: true, ..Default::default() }, + Param { type_name: "composite".to_string(), ..Default::default() }, + ]; + assert_eq!( + parse_dispatchable_arguments(¶ms, args)?, + [ + Value::u128(1), + Value::i128(-1), + Value::bool(true), + Value::char('a'), + Value::string("hi"), + Value::named_composite(vec![ + ("a", Value::bool(true)), + ("b", Value::string("hello")) + ]), + Value::named_variant( + "MyVariant", + vec![("a", Value::bool(true)), ("b", Value::string("hello"))] + ), + Value::bit_sequence(scale_bits::Bits::from_iter([false, true, false, true])), + Value::unnamed_composite(vec![ + Value::u128(1), + Value::u128(2), + Value::unnamed_composite(vec![Value::u128(3), Value::u128(4), Value::u128(5),]) + ]), + Value::named_composite(vec![ + ("name", Value::string("Alice")), + ("address", Value::unnamed_composite(addr)) + ]) + ] + ); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/metadata/params.rs b/crates/pop-parachains/src/call/metadata/params.rs new file mode 100644 index 000000000..9d8521f9c --- /dev/null +++ b/crates/pop-parachains/src/call/metadata/params.rs @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::errors::Error; +use pop_common::format_type; +use scale_info::{form::PortableForm, Field, PortableRegistry, TypeDef}; +use subxt::Metadata; + +/// Describes a parameter of a dispatchable function. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct Param { + /// The name of the parameter. + pub name: String, + /// The type of the parameter. + pub type_name: String, + /// Nested parameters for composite, variants, types or tuples. + pub sub_params: Vec, + /// Indicates if the parameter is optional (`Option`). + pub is_optional: bool, + /// Indicates if the parameter is a Tuple. + pub is_tuple: bool, + /// Indicates if the parameter is a Variant. + pub is_variant: bool, + /// Indicates if the parameter is a Sequence. + pub is_sequence: bool, +} + +/// Transforms a metadata field into its `Param` representation. +/// +/// # Arguments +/// * `metadata`: The chain metadata. +/// * `field`: A parameter of a dispatchable function (as [Field]). +pub fn field_to_param(metadata: &Metadata, field: &Field) -> Result { + let registry = metadata.types(); + if let Some(name) = field.type_name.as_deref() { + if name.contains("RuntimeCall") { + return Err(Error::FunctionNotSupported); + } + } + let name = field.name.as_deref().unwrap_or("Unnamed"); //It can be unnamed field + type_to_param(name, registry, field.ty.id) +} + +/// Converts a type's metadata into a `Param` representation. +/// +/// # Arguments +/// * `name`: The name of the parameter. +/// * `registry`: Type registry containing all types used in the metadata. +/// * `type_id`: The ID of the type to be converted. +fn type_to_param(name: &str, registry: &PortableRegistry, type_id: u32) -> Result { + let type_info = registry + .resolve(type_id) + .ok_or_else(|| Error::MetadataParsingError(name.to_string()))?; + for param in &type_info.type_params { + if param.name.contains("RuntimeCall") { + return Err(Error::FunctionNotSupported); + } + } + if type_info.path.segments == ["Option"] { + if let Some(sub_type_id) = type_info.type_params.first().and_then(|param| param.ty) { + // Recursive for the sub parameters + let sub_param = type_to_param(name, registry, sub_type_id.id)?; + Ok(Param { + name: name.to_string(), + type_name: sub_param.type_name, + sub_params: sub_param.sub_params, + is_optional: true, + ..Default::default() + }) + } else { + Err(Error::MetadataParsingError(name.to_string())) + } + } else { + // Determine the formatted type name. + let type_name = format_type(type_info, registry); + match &type_info.type_def { + TypeDef::Primitive(_) | TypeDef::Array(_) | TypeDef::Compact(_) => + Ok(Param { name: name.to_string(), type_name, ..Default::default() }), + TypeDef::Composite(composite) => { + let sub_params = composite + .fields + .iter() + .map(|field| { + // Recursive for the sub parameters of composite type. + type_to_param(field.name.as_deref().unwrap_or(name), registry, field.ty.id) + }) + .collect::, Error>>()?; + + Ok(Param { name: name.to_string(), type_name, sub_params, ..Default::default() }) + }, + TypeDef::Variant(variant) => { + let variant_params = variant + .variants + .iter() + .map(|variant_param| { + let variant_sub_params = variant_param + .fields + .iter() + .map(|field| { + // Recursive for the sub parameters of variant type. + type_to_param( + field.name.as_deref().unwrap_or(&variant_param.name), + registry, + field.ty.id, + ) + }) + .collect::, Error>>()?; + Ok(Param { + name: variant_param.name.clone(), + type_name: "".to_string(), + sub_params: variant_sub_params, + is_variant: true, + ..Default::default() + }) + }) + .collect::, Error>>()?; + + Ok(Param { + name: name.to_string(), + type_name, + sub_params: variant_params, + is_variant: true, + ..Default::default() + }) + }, + TypeDef::Sequence(_) => Ok(Param { + name: name.to_string(), + type_name, + is_sequence: true, + ..Default::default() + }), + TypeDef::Tuple(tuple) => { + let sub_params = tuple + .fields + .iter() + .enumerate() + .map(|(index, field_id)| { + type_to_param( + &format!("Index {index} of the tuple {name}"), + registry, + field_id.id, + ) + }) + .collect::, Error>>()?; + + Ok(Param { + name: name.to_string(), + type_name, + sub_params, + is_tuple: true, + ..Default::default() + }) + }, + _ => Err(Error::MetadataParsingError(name.to_string())), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{call::tests::POP_NETWORK_TESTNET_URL, set_up_client}; + use anyhow::Result; + + #[tokio::test] + async fn field_to_param_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let metadata = client.metadata(); + // Test a supported dispatchable function. + let function = metadata + .pallet_by_name("Balances") + .unwrap() + .call_variant_by_name("force_transfer") + .unwrap(); + let mut params = Vec::new(); + for field in &function.fields { + params.push(field_to_param(&metadata, field)?) + } + assert_eq!(params.len(), 3); + assert_eq!(params.first().unwrap().name, "source"); + assert_eq!(params.first().unwrap().type_name, "MultiAddress: Id(AccountId32 ([u8;32])), Index(Compact<()>), Raw([u8]), Address32([u8;32]), Address20([u8;20])"); + assert_eq!(params.first().unwrap().sub_params.len(), 5); + assert_eq!(params.first().unwrap().sub_params.first().unwrap().name, "Id"); + assert_eq!(params.first().unwrap().sub_params.first().unwrap().type_name, ""); + assert_eq!( + params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .name, + "Id" + ); + assert_eq!( + params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .sub_params + .first() + .unwrap() + .type_name, + "AccountId32 ([u8;32])" + ); + // Test some dispatchable functions that are not supported. + let function = + metadata.pallet_by_name("Sudo").unwrap().call_variant_by_name("sudo").unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + let function = metadata + .pallet_by_name("Utility") + .unwrap() + .call_variant_by_name("batch") + .unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + let function = metadata + .pallet_by_name("PolkadotXcm") + .unwrap() + .call_variant_by_name("execute") + .unwrap(); + assert!(matches!( + field_to_param(&metadata, &function.fields.first().unwrap()), + Err(Error::FunctionNotSupported) + )); + + Ok(()) + } +} diff --git a/crates/pop-parachains/src/call/mod.rs b/crates/pop-parachains/src/call/mod.rs new file mode 100644 index 000000000..4569687ec --- /dev/null +++ b/crates/pop-parachains/src/call/mod.rs @@ -0,0 +1,263 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::{errors::Error, Function}; +use pop_common::{ + call::{DefaultEnvironment, DisplayEvents, TokenMetadata, Verbosity}, + create_signer, +}; +use sp_core::bytes::{from_hex, to_hex}; +use subxt::{ + dynamic::Value, + tx::{DynamicPayload, Payload, SubmittableExtrinsic}, + OnlineClient, SubstrateConfig, +}; +pub mod metadata; + +/// Sets up an [OnlineClient] instance for connecting to a blockchain. +/// +/// # Arguments +/// * `url` - Endpoint of the node. +pub async fn set_up_client(url: &str) -> Result, Error> { + OnlineClient::::from_url(url) + .await + .map_err(|e| Error::ConnectionFailure(e.to_string())) +} + +/// Constructs a dynamic extrinsic payload for a specified dispatchable function. +/// +/// # Arguments +/// * `function` - A dispatchable function. +/// * `args` - A vector of string arguments to be passed to construct the extrinsic. +pub fn construct_extrinsic( + function: &Function, + args: Vec, +) -> Result { + let parsed_args: Vec = metadata::parse_dispatchable_arguments(&function.params, args)?; + Ok(subxt::dynamic::tx(function.pallet.clone(), function.name.clone(), parsed_args)) +} + +/// Constructs a Sudo extrinsic. +/// +/// # Arguments +/// * `xt`: The extrinsic representing the dispatchable function call to be dispatched with `Root` +/// privileges. +pub fn construct_sudo_extrinsic(xt: DynamicPayload) -> DynamicPayload { + subxt::dynamic::tx("Sudo", "sudo", [xt.into_value()].to_vec()) +} + +/// Signs and submits a given extrinsic. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `url` - Endpoint of the node. +/// * `xt` - The (encoded) extrinsic to be signed and submitted. +/// * `suri` - The secret URI (e.g., mnemonic or private key) for signing the extrinsic. +pub async fn sign_and_submit_extrinsic( + client: &OnlineClient, + url: &url::Url, + xt: Xt, + suri: &str, +) -> Result { + let signer = create_signer(suri)?; + let result = client + .tx() + .sign_and_submit_then_watch_default(&xt, &signer) + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))? + .wait_for_finalized_success() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))?; + + // Obtain required metadata and parse events. The following is using existing logic from + // `cargo-contract`, also used in calling contracts, due to simplicity and can be refactored in + // the future. + let metadata = client.metadata(); + let token_metadata = TokenMetadata::query::(url).await?; + let events = DisplayEvents::from_events::( + &result, None, &metadata, + )?; + let events = + events.display_events::(Verbosity::Default, &token_metadata)?; + + Ok(format!("Extrinsic Submitted with hash: {:?}\n\n{}", result.extrinsic_hash(), events)) +} + +/// Submits a signed extrinsic. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `payload` - The signed payload string to be submitted. +pub async fn submit_signed_extrinsic( + client: OnlineClient, + payload: String, +) -> Result { + let hex_encoded = + from_hex(&payload).map_err(|e| Error::CallDataDecodingError(e.to_string()))?; + let extrinsic = SubmittableExtrinsic::from_bytes(client, hex_encoded); + let result = extrinsic + .submit_and_watch() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))? + .wait_for_finalized_success() + .await + .map_err(|e| Error::ExtrinsicSubmissionError(format!("{:?}", e)))?; + Ok(format!("{:?}", result.extrinsic_hash())) +} + +/// Encodes the call data for a given extrinsic into a hexadecimal string. +/// +/// # Arguments +/// * `client` - The client used to interact with the chain. +/// * `xt` - The extrinsic whose call data will be encoded and returned. +pub fn encode_call_data( + client: &OnlineClient, + xt: &DynamicPayload, +) -> Result { + let call_data = xt + .encode_call_data(&client.metadata()) + .map_err(|e| Error::CallDataEncodingError(e.to_string()))?; + Ok(to_hex(&call_data, false)) +} + +/// Decodes a hex-encoded string into a vector of bytes representing the call data. +/// +/// # Arguments +/// * `call_data` - The hex-encoded string representing call data. +pub fn decode_call_data(call_data: &str) -> Result, Error> { + from_hex(call_data).map_err(|e| Error::CallDataDecodingError(e.to_string())) +} + +/// This struct implements the [`Payload`] trait and is used to submit +/// pre-encoded SCALE call data directly, without the dynamic construction of transactions. +pub struct CallData(Vec); + +impl CallData { + /// Create a new instance of `CallData`. + pub fn new(data: Vec) -> CallData { + CallData(data) + } +} + +impl Payload for CallData { + fn encode_call_data_to( + &self, + _: &subxt::Metadata, + out: &mut Vec, + ) -> Result<(), subxt::ext::subxt_core::Error> { + out.extend_from_slice(&self.0); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{find_dispatchable_by_name, parse_chain_metadata, set_up_client}; + use anyhow::Result; + use url::Url; + + const ALICE_SURI: &str = "//Alice"; + pub(crate) const POP_NETWORK_TESTNET_URL: &str = "wss://rpc1.paseo.popnetwork.xyz"; + + #[tokio::test] + async fn set_up_client_works() -> Result<()> { + assert!(matches!( + set_up_client("wss://wronguri.xyz").await, + Err(Error::ConnectionFailure(_)) + )); + set_up_client(POP_NETWORK_TESTNET_URL).await?; + Ok(()) + } + + #[tokio::test] + async fn construct_extrinsic_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let transfer_allow_death = + find_dispatchable_by_name(&pallets, "Balances", "transfer_allow_death")?; + + // Wrong parameters + assert!(matches!( + construct_extrinsic( + &transfer_allow_death, + vec![ALICE_SURI.to_string(), "100".to_string()], + ), + Err(Error::ParamProcessingError) + )); + // Valid parameters + let xt = construct_extrinsic( + &transfer_allow_death, + vec![ + "Id(5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty)".to_string(), + "100".to_string(), + ], + )?; + assert_eq!(xt.call_name(), "transfer_allow_death"); + assert_eq!(xt.pallet_name(), "Balances"); + Ok(()) + } + + #[tokio::test] + async fn encode_call_data_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let remark = find_dispatchable_by_name(&pallets, "System", "remark")?; + let xt = construct_extrinsic(&remark, vec!["0x11".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00000411"); + let xt = construct_extrinsic(&remark, vec!["123".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00000c313233"); + let xt = construct_extrinsic(&remark, vec!["test".to_string()])?; + assert_eq!(encode_call_data(&client, &xt)?, "0x00001074657374"); + Ok(()) + } + + #[tokio::test] + async fn decode_call_data_works() -> Result<()> { + assert!(matches!(decode_call_data("wrongcalldata"), Err(Error::CallDataDecodingError(..)))); + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let remark = find_dispatchable_by_name(&pallets, "System", "remark")?; + let xt = construct_extrinsic(&remark, vec!["0x11".to_string()])?; + let expected_call_data = xt.encode_call_data(&client.metadata())?; + assert_eq!(decode_call_data("0x00000411")?, expected_call_data); + Ok(()) + } + + #[tokio::test] + async fn sign_and_submit_wrong_extrinsic_fails() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let function = Function { + pallet: "WrongPallet".to_string(), + name: "wrong_extrinsic".to_string(), + index: 0, + docs: "documentation".to_string(), + is_supported: true, + ..Default::default() + }; + let xt = construct_extrinsic(&function, vec!["0x11".to_string()])?; + assert!(matches!( + sign_and_submit_extrinsic(&client, &Url::parse(POP_NETWORK_TESTNET_URL)?, xt, ALICE_SURI).await, + Err(Error::ExtrinsicSubmissionError(message)) if message.contains("PalletNameNotFound(\"WrongPallet\"))") + )); + Ok(()) + } + + #[tokio::test] + async fn construct_sudo_extrinsic_works() -> Result<()> { + let client = set_up_client(POP_NETWORK_TESTNET_URL).await?; + let pallets = parse_chain_metadata(&client)?; + let force_transfer = find_dispatchable_by_name(&pallets, "Balances", "force_transfer")?; + let xt = construct_extrinsic( + &force_transfer, + vec![ + "Id(5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty)".to_string(), + "Id(5DAAnrj7VHTznn2AWBemMuyBwZWs6FNFjdyVXUeYum3PTXFy)".to_string(), + "100".to_string(), + ], + )?; + let xt = construct_sudo_extrinsic(xt); + assert_eq!(xt.call_name(), "sudo"); + assert_eq!(xt.pallet_name(), "Sudo"); + Ok(()) + } +} diff --git a/crates/pop-parachains/src/errors.rs b/crates/pop-parachains/src/errors.rs index 3eff7bbfc..2dd8805ac 100644 --- a/crates/pop-parachains/src/errors.rs +++ b/crates/pop-parachains/src/errors.rs @@ -3,24 +3,43 @@ use thiserror::Error; use zombienet_sdk::OrchestratorError; +/// Represents the various errors that can occur in the crate. #[derive(Error, Debug)] pub enum Error { #[error("User aborted due to existing target directory.")] Aborted, #[error("Anyhow error: {0}")] AnyhowError(#[from] anyhow::Error), + /// An error occurred while decoding the call data. + #[error("Failed to decode call data. {0}")] + CallDataDecodingError(String), + /// An error occurred while encoding the call data. + #[error("Failed to encode call data. {0}")] + CallDataEncodingError(String), #[error("{0}")] CommonError(#[from] pop_common::Error), + /// An error occurred while attempting to establish a connection to the endpoint. + #[error("Failed to establish a connection to: {0}")] + ConnectionFailure(String), #[error("Configuration error: {0}")] Config(String), #[error("Failed to access the current directory")] CurrentDirAccess, #[error("Failed to parse the endowment value")] EndowmentError, + /// An error occurred during the submission of an extrinsic. + #[error("Extrinsic submission error: {0}")] + ExtrinsicSubmissionError(String), + /// The dispatchable function is not supported. + #[error("The dispatchable function is not supported")] + FunctionNotSupported, #[error("IO error: {0}")] IO(#[from] std::io::Error), #[error("JSON error: {0}")] JsonError(#[from] serde_json::Error), + /// An error occurred while parsing metadata of a parameter. + #[error("Error parsing metadata for parameter {0}")] + MetadataParsingError(String), #[error("Missing binary: {0}")] MissingBinary(String), #[error("Missing chain spec file at: {0}")] @@ -31,12 +50,21 @@ pub enum Error { OrchestratorError(#[from] OrchestratorError), #[error("Failed to create pallet directory")] PalletDirCreation, + /// The specified pallet could not be found. + #[error("Failed to find the pallet {0}")] + PalletNotFound(String), + /// An error occurred while processing the arguments provided by the user. + #[error("Failed to process the arguments provided by the user.")] + ParamProcessingError, #[error("Invalid path")] PathError, #[error("Failed to execute rustfmt")] RustfmtError(std::io::Error), #[error("Template error: {0}")] SourcingError(#[from] pop_common::sourcing::Error), + /// An error occurred whilst interacting with a chain using `subxt`. + #[error("Subxt error: {0}")] + SubXtError(#[from] subxt::Error), #[error("Toml error: {0}")] TomlError(#[from] toml_edit::de::Error), #[error("Unsupported command: {0}")] diff --git a/crates/pop-parachains/src/lib.rs b/crates/pop-parachains/src/lib.rs index 06bee8f4a..50bb6af5b 100644 --- a/crates/pop-parachains/src/lib.rs +++ b/crates/pop-parachains/src/lib.rs @@ -2,10 +2,13 @@ #![doc = include_str!("../README.md")] mod build; +/// Provides functionality to construct, encode, sign, and submit chain extrinsics. +mod call; mod errors; mod generator; mod new_pallet; mod new_parachain; +mod relay; mod templates; mod up; mod utils; @@ -14,10 +17,26 @@ pub use build::{ binary_path, build_parachain, export_wasm_file, generate_genesis_state_file, generate_plain_chain_spec, generate_raw_chain_spec, is_supported, ChainSpec, }; +pub use call::{ + construct_extrinsic, construct_sudo_extrinsic, decode_call_data, encode_call_data, + metadata::{ + action::{supported_actions, Action}, + find_dispatchable_by_name, find_pallet_by_name, + params::Param, + parse_chain_metadata, Function, Pallet, + }, + set_up_client, sign_and_submit_extrinsic, submit_signed_extrinsic, CallData, +}; pub use errors::Error; pub use indexmap::IndexSet; pub use new_pallet::{create_pallet_template, new_pallet_options::*, TemplatePalletConfig}; pub use new_parachain::instantiate_template_dir; +pub use relay::{clear_dmpq, RelayChain}; +// External export from subxt. +pub use subxt::{ + tx::{DynamicPayload, Payload}, + OnlineClient, SubstrateConfig, +}; pub use templates::{Config, Parachain, Provider}; pub use up::Zombienet; pub use utils::helpers::is_initial_endowment_valid; diff --git a/crates/pop-parachains/src/new_parachain.rs b/crates/pop-parachains/src/new_parachain.rs index 8974cfede..f9e28e527 100644 --- a/crates/pop-parachains/src/new_parachain.rs +++ b/crates/pop-parachains/src/new_parachain.rs @@ -87,12 +87,7 @@ pub fn instantiate_openzeppelin_template( let source = temp_dir.path(); let tag = Git::clone_and_degit(template.repository_url()?, source, tag_version)?; - let mut template_name = template.template_name_without_provider(); - // Handle deprecated OpenZeppelin template - if matches!(template, Parachain::DeprecatedOpenZeppelinGeneric) { - template_name = Parachain::OpenZeppelinGeneric.template_name_without_provider(); - } - + let template_name = template.template_name_without_provider(); extract_template_files(template_name, temp_dir.path(), target, None)?; Ok(tag) } diff --git a/crates/pop-parachains/src/relay.rs b/crates/pop-parachains/src/relay.rs new file mode 100644 index 000000000..6ded8c497 --- /dev/null +++ b/crates/pop-parachains/src/relay.rs @@ -0,0 +1,146 @@ +// SPDX-License-Identifier: GPL-3.0 + +use crate::{call, DynamicPayload, Error}; +use sp_core::twox_128; +use subxt::{ + config::BlockHash, + dynamic::{self, Value}, + ext::sp_core, + OnlineClient, PolkadotConfig, +}; + +/// Clears the DMPQ state for the given parachain IDs. +/// +/// # Arguments +/// * `client` - Client for the network which state is to be modified. +/// * `para_ids` - List of ids to build the keys that will be mutated. +pub async fn clear_dmpq( + client: OnlineClient, + para_ids: &[u32], +) -> Result { + // Wait for blocks to be produced. + let mut sub = client.blocks().subscribe_finalized().await?; + for _ in 0..2 { + sub.next().await; + } + + // Generate storage keys to be removed + let clear_dmq_keys = generate_storage_keys(para_ids); + + // Submit calls to remove specified keys + let kill_storage = construct_kill_storage_call(clear_dmq_keys); + let sudo = subxt_signer::sr25519::dev::alice(); + let sudo_call = call::construct_sudo_extrinsic(kill_storage); + Ok(client.tx().sign_and_submit_default(&sudo_call, &sudo).await?) +} + +fn construct_kill_storage_call(keys: Vec>) -> DynamicPayload { + dynamic::tx( + "System", + "kill_storage", + vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], + ) +} + +fn generate_storage_keys(para_ids: &[u32]) -> Vec> { + let dmp = twox_128("Dmp".as_bytes()); + let dmp_queue_heads = twox_128("DownwardMessageQueueHeads".as_bytes()); + let dmp_queues = twox_128("DownwardMessageQueues".as_bytes()); + let mut clear_dmq_keys = Vec::>::new(); + for id in para_ids { + let id = id.to_le_bytes(); + // DMP Queue Head + let mut key = dmp.to_vec(); + key.extend(&dmp_queue_heads); + key.extend(sp_core::twox_64(&id)); + key.extend(id); + clear_dmq_keys.push(key); + // DMP Queue + let mut key = dmp.to_vec(); + key.extend(&dmp_queues); + key.extend(sp_core::twox_64(&id)); + key.extend(id); + clear_dmq_keys.push(key); + } + clear_dmq_keys +} + +/// A supported relay chain. +#[derive(Debug, PartialEq)] +pub enum RelayChain { + /// Paseo. + PaseoLocal, + /// Westend. + WestendLocal, +} + +impl RelayChain { + /// Attempts to convert a chain identifier into a supported `RelayChain` variant. + /// + /// # Arguments + /// * `id` - The relay chain identifier. + pub fn from(id: &str) -> Option { + match id { + "paseo-local" => Some(RelayChain::PaseoLocal), + "westend-local" => Some(RelayChain::WestendLocal), + _ => None, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use subxt::ext::sp_core::twox_64; + use RelayChain::*; + + #[test] + fn construct_kill_storage_call_works() { + let keys = vec!["key".as_bytes().to_vec()]; + assert_eq!( + construct_kill_storage_call(keys.clone()), + dynamic::tx( + "System", + "kill_storage", + vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], + ) + ) + } + + #[test] + fn generate_storage_keys_works() { + let para_ids = vec![1_000, 4_385]; + let dmp = twox_128("Dmp".as_bytes()); + let dmp_queue_heads = [dmp, twox_128("DownwardMessageQueueHeads".as_bytes())].concat(); + let dmp_queues = [dmp, twox_128("DownwardMessageQueues".as_bytes())].concat(); + + assert_eq!( + generate_storage_keys(¶_ids), + para_ids + .iter() + .flat_map(|id| { + let id = id.to_le_bytes().to_vec(); + [ + // DMP Queue Head + [dmp_queue_heads.clone(), twox_64(&id).to_vec(), id.clone()].concat(), + // DMP Queue + [dmp_queues.clone(), twox_64(&id).to_vec(), id].concat(), + ] + }) + .collect::>() + ) + } + + #[test] + fn supported_relay_chains() { + for (s, e) in [ + // Only chains with sudo supported + ("paseo-local", Some(PaseoLocal)), + ("westend-local", Some(WestendLocal)), + ("kusama-local", None), + ("polkadot-local", None), + ] { + assert_eq!(RelayChain::from(s), e) + } + } +} diff --git a/crates/pop-parachains/src/templates.rs b/crates/pop-parachains/src/templates.rs index 0f9ba5794..324f6f23f 100644 --- a/crates/pop-parachains/src/templates.rs +++ b/crates/pop-parachains/src/templates.rs @@ -177,23 +177,6 @@ pub enum Parachain { ) )] ParityFPT, - // OpenZeppelin - #[strum( - serialize = "polkadot-generic-runtime-template", - message = "Generic Runtime Template", - detailed_message = "A generic template for Substrate Runtime.", - props( - Provider = "OpenZeppelin", - Repository = "https://github.com/OpenZeppelin/polkadot-runtime-templates", - Network = "./zombienet-config/devnet.toml", - SupportedVersions = "v1.0.0,v2.0.1", - IsAudited = "true", - License = "GPL-3.0", - IsDeprecated = "true", - DeprecatedMessage = "This template is deprecated. Please use openzeppelin/generic-template in the future.", - ) - )] - DeprecatedOpenZeppelinGeneric, // templates for unit tests below #[cfg(test)] #[strum( @@ -273,7 +256,6 @@ mod tests { // openzeppelin ("openzeppelin/generic-template".to_string(), OpenZeppelinGeneric), ("openzeppelin/evm-template".to_string(), OpenZeppelinEVM), - ("polkadot-generic-runtime-template".to_string(), DeprecatedOpenZeppelinGeneric), ("cpt".to_string(), ParityContracts), ("fpt".to_string(), ParityFPT), ("test_01".to_string(), TestTemplate01), @@ -289,7 +271,6 @@ mod tests { (EVM, "evm".to_string()), (OpenZeppelinGeneric, "generic-template".to_string()), (OpenZeppelinEVM, "evm-template".to_string()), - (DeprecatedOpenZeppelinGeneric, "polkadot-generic-runtime-template".to_string()), (ParityContracts, "cpt".to_string()), (ParityFPT, "fpt".to_string()), (TestTemplate01, "test_01".to_string()), @@ -331,7 +312,6 @@ mod tests { (EVM, Some("./network.toml")), (OpenZeppelinGeneric, Some("./zombienet-config/devnet.toml")), (OpenZeppelinEVM, Some("./zombienet-config/devnet.toml")), - (DeprecatedOpenZeppelinGeneric, Some("./zombienet-config/devnet.toml")), (ParityContracts, Some("./zombienet.toml")), (ParityFPT, Some("./zombienet-config.toml")), (TestTemplate01, Some("")), @@ -348,7 +328,6 @@ mod tests { (EVM, Some("Unlicense")), (OpenZeppelinGeneric, Some("GPL-3.0")), (OpenZeppelinEVM, Some("GPL-3.0")), - (DeprecatedOpenZeppelinGeneric, Some("GPL-3.0")), (ParityContracts, Some("Unlicense")), (ParityFPT, Some("Unlicense")), (TestTemplate01, Some("Unlicense")), diff --git a/crates/pop-parachains/src/up/chain_specs.rs b/crates/pop-parachains/src/up/chain_specs.rs index 3513a587e..e81db7ee9 100644 --- a/crates/pop-parachains/src/up/chain_specs.rs +++ b/crates/pop-parachains/src/up/chain_specs.rs @@ -22,7 +22,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/polkadot-runtimes", Binary = "chain-spec-generator", Chain = "kusama-local", - Fallback = "v1.2.7" + Fallback = "v1.3.3" ))] Kusama, /// Paseo. @@ -30,7 +30,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/paseo-runtimes", Binary = "chain-spec-generator", Chain = "paseo-local", - Fallback = "v1.2.6" + Fallback = "v1.3.4" ))] Paseo, /// Polkadot. @@ -38,7 +38,7 @@ pub(super) enum Runtime { Repository = "https://github.com/r0gue-io/polkadot-runtimes", Binary = "chain-spec-generator", Chain = "polkadot-local", - Fallback = "v1.2.7" + Fallback = "v1.3.3" ))] Polkadot, } @@ -111,7 +111,7 @@ mod tests { #[tokio::test] async fn kusama_works() -> anyhow::Result<()> { let expected = Runtime::Kusama; - let version = "v1.2.7"; + let version = "v1.3.3"; let temp_dir = tempdir()?; let binary = chain_spec_generator("kusama-local", Some(version), temp_dir.path()) .await? @@ -135,7 +135,7 @@ mod tests { #[tokio::test] async fn paseo_works() -> anyhow::Result<()> { let expected = Runtime::Paseo; - let version = "v1.2.4"; + let version = "v1.3.4"; let temp_dir = tempdir()?; let binary = chain_spec_generator("paseo-local", Some(version), temp_dir.path()) .await? @@ -159,7 +159,7 @@ mod tests { #[tokio::test] async fn polkadot_works() -> anyhow::Result<()> { let expected = Runtime::Polkadot; - let version = "v1.2.7"; + let version = "v1.3.3"; let temp_dir = tempdir()?; let binary = chain_spec_generator("polkadot-local", Some(version), temp_dir.path()) .await? diff --git a/crates/pop-parachains/src/up/mod.rs b/crates/pop-parachains/src/up/mod.rs index 036ae889d..abefa8051 100644 --- a/crates/pop-parachains/src/up/mod.rs +++ b/crates/pop-parachains/src/up/mod.rs @@ -30,6 +30,8 @@ pub struct Zombienet { relay_chain: RelayChain, /// The configuration required to launch parachains. parachains: IndexMap, + /// Whether any HRMP channels are to be pre-opened. + hrmp_channels: bool, } impl Zombienet { @@ -59,7 +61,7 @@ impl Zombienet { // Parse network config let network_config = NetworkConfiguration::from(network_config)?; // Determine relay and parachain requirements based on arguments and config - let relay_chain = Self::relay_chain( + let relay_chain = Self::init_relay_chain( relay_chain_version, relay_chain_runtime_version, &network_config, @@ -84,7 +86,9 @@ impl Zombienet { cache, ) .await?; - Ok(Self { network_config, relay_chain, parachains }) + let hrmp_channels = + network_config.hrmp_channels().map(|c| !c.is_empty()).unwrap_or_default(); + Ok(Self { network_config, relay_chain, parachains, hrmp_channels }) } /// The binaries required to launch the network. @@ -216,7 +220,7 @@ impl Zombienet { /// will use the latest available version). /// * `network_config` - The network configuration to be used to launch a network. /// * `cache` - The location used for caching binaries. - async fn relay_chain( + async fn init_relay_chain( version: Option<&str>, runtime_version: Option<&str>, network_config: &NetworkConfiguration, @@ -276,6 +280,16 @@ impl Zombienet { Ok(relay::default(version, runtime_version, chain, cache).await?) } + /// The name of the relay chain. + pub fn relay_chain(&self) -> &str { + &self.relay_chain.chain + } + + /// Whether any HRMP channels are to be pre-opened. + pub fn hrmp_channels(&self) -> bool { + self.hrmp_channels + } + /// Launches the local network. pub async fn spawn(&mut self) -> Result, Error> { // Symlink polkadot workers @@ -354,6 +368,11 @@ impl NetworkConfiguration { self.0.get_mut("parachains").and_then(|p| p.as_array_of_tables_mut()) } + /// Returns the `hrmp_channels` configuration. + fn hrmp_channels(&self) -> Option<&ArrayOfTables> { + self.0.get("hrmp_channels").and_then(|p| p.as_array_of_tables()) + } + /// Returns the `command` configuration. fn command(config: &Table) -> Option<&Item> { config.get("command") @@ -660,6 +679,8 @@ mod tests { use std::{env::current_dir, fs::File, io::Write}; use tempfile::tempdir; + pub(crate) const VERSION: &str = "stable2409"; + mod zombienet { use super::*; use pop_common::Status; @@ -683,12 +704,11 @@ mod tests { chain = "paseo-local" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -698,14 +718,16 @@ chain = "paseo-local" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); + assert_eq!(zombienet.relay_chain(), "paseo-local"); + assert!(!zombienet.hrmp_channels()); Ok(()) } @@ -721,7 +743,7 @@ chain = "paseo-local" chain = "paseo-local" "# )?; - let version = "v1.2.7"; + let version = "v1.3.3"; let zombienet = Zombienet::new( &cache, @@ -761,15 +783,14 @@ chain = "paseo-local" r#" [relaychain] chain = "paseo-local" -default_command = "./bin-v1.6.0/polkadot" +default_command = "./bin-stable2409/polkadot" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -779,12 +800,12 @@ default_command = "./bin-v1.6.0/polkadot" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); Ok(()) @@ -807,12 +828,11 @@ validator = true command = "polkadot" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some(version), + Some(VERSION), None, None, None, @@ -822,12 +842,12 @@ command = "polkadot" let relay_chain = &zombienet.relay_chain.binary; assert_eq!(relay_chain.name(), "polkadot"); - assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{version}"))); - assert_eq!(relay_chain.version().unwrap(), version); + assert_eq!(relay_chain.path(), temp_dir.path().join(format!("polkadot-{VERSION}"))); + assert_eq!(relay_chain.version().unwrap(), VERSION); assert!(matches!( relay_chain, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); assert!(zombienet.parachains.is_empty()); Ok(()) @@ -852,14 +872,14 @@ command = "polkadot" [[relaychain.nodes]] name = "bob" validator = true -command = "polkadot-v1.12.0" +command = "polkadot-stable2409" "# )?; assert!(matches!( Zombienet::new(&cache, config.path().to_str().unwrap(), None, None, None, None, None).await, Err(Error::UnsupportedCommand(error)) - if error == "the relay chain command is unsupported: polkadot-v1.12.0" + if error == "the relay chain command is unsupported: polkadot-stable2409" )); Ok(()) } @@ -879,14 +899,14 @@ default_command = "polkadot" [[relaychain.nodes]] name = "alice" validator = true -command = "polkadot-v1.12.0" +command = "polkadot-stable2409" "# )?; assert!(matches!( Zombienet::new(&cache, config.path().to_str().unwrap(), None, None, None, None, None).await, Err(Error::UnsupportedCommand(error)) - if error == "the relay chain command is unsupported: polkadot-v1.12.0" + if error == "the relay chain command is unsupported: polkadot-stable2409" )); Ok(()) } @@ -907,12 +927,12 @@ id = 1000 chain = "asset-hub-paseo-local" "# )?; - let system_parachain_version = "v1.12.0"; + let system_parachain_version = "stable2407"; let zombienet = Zombienet::new( &cache, config.path().to_str().unwrap(), - Some("v1.11.0"), + Some(VERSION), None, Some(system_parachain_version), None, @@ -952,7 +972,6 @@ id = 1000 chain = "asset-hub-paseo-local" "# )?; - let version = "v1.12.0"; let zombienet = Zombienet::new( &cache, @@ -960,7 +979,7 @@ chain = "asset-hub-paseo-local" None, None, None, - Some(version), + Some(VERSION), None, ) .await?; @@ -972,13 +991,13 @@ chain = "asset-hub-paseo-local" assert_eq!(chain_spec_generator.name(), "paseo-chain-spec-generator"); assert_eq!( chain_spec_generator.path(), - temp_dir.path().join(format!("paseo-chain-spec-generator-{version}")) + temp_dir.path().join(format!("paseo-chain-spec-generator-{VERSION}")) ); - assert_eq!(chain_spec_generator.version().unwrap(), version); + assert_eq!(chain_spec_generator.version().unwrap(), VERSION); assert!(matches!( chain_spec_generator, Binary::Source { source: Source::GitHub(ReleaseArchive { tag, .. }), .. } - if *tag == Some(version.to_string()) + if *tag == Some(VERSION.to_string()) )); Ok(()) } @@ -1186,6 +1205,48 @@ default_command = "moonbeam" Ok(()) } + #[tokio::test] + async fn new_with_hrmp_channels_works() -> Result<()> { + let temp_dir = tempdir()?; + let cache = PathBuf::from(temp_dir.path()); + let config = Builder::new().suffix(".toml").tempfile()?; + writeln!( + config.as_file(), + r#" +[relaychain] +chain = "paseo-local" + +[[parachains]] +id = 1000 +chain = "asset-hub-paseo-local" + +[[parachains]] +id = 4385 +default_command = "pop-node" + +[[hrmp_channels]] +sender = 4385 +recipient = 1000 +max_capacity = 1000 +max_message_size = 8000 +"# + )?; + + let zombienet = Zombienet::new( + &cache, + config.path().to_str().unwrap(), + None, + None, + None, + None, + None, + ) + .await?; + + assert!(zombienet.hrmp_channels()); + Ok(()) + } + #[tokio::test] async fn new_ensures_parachain_id_exists() -> Result<()> { let temp_dir = tempdir()?; @@ -1384,10 +1445,9 @@ chain = "paseo-local" chain = "paseo-local" "# )?; - let version = "v1.12.0"; - File::create(cache.join(format!("polkadot-{version}")))?; - File::create(cache.join(format!("polkadot-execute-worker-{version}")))?; - File::create(cache.join(format!("polkadot-prepare-worker-{version}")))?; + File::create(cache.join(format!("polkadot-{VERSION}")))?; + File::create(cache.join(format!("polkadot-execute-worker-{VERSION}")))?; + File::create(cache.join(format!("polkadot-prepare-worker-{VERSION}")))?; let mut zombienet = Zombienet::new( &cache, diff --git a/crates/pop-parachains/src/up/parachains.rs b/crates/pop-parachains/src/up/parachains.rs index 06eda16e6..ad6075454 100644 --- a/crates/pop-parachains/src/up/parachains.rs +++ b/crates/pop-parachains/src/up/parachains.rs @@ -22,7 +22,7 @@ pub(super) enum Parachain { Repository = "https://github.com/r0gue-io/polkadot", Binary = "polkadot-parachain", TagFormat = "polkadot-{tag}", - Fallback = "v1.12.0" + Fallback = "stable2409" ))] System, /// Pop Network makes it easy for smart contract developers to use the power of Polkadot. @@ -30,7 +30,7 @@ pub(super) enum Parachain { Repository = "https://github.com/r0gue-io/pop-node", Binary = "pop-node", Prerelease = "false", - Fallback = "testnet-v0.4.1" + Fallback = "testnet-v0.4.2" ))] Pop, } @@ -148,7 +148,7 @@ pub(super) async fn from( #[cfg(test)] mod tests { - use super::*; + use super::{super::tests::VERSION, *}; use std::path::PathBuf; use tempfile::tempdir; @@ -159,7 +159,7 @@ mod tests { "polkadot", None, None, - "v1.12.0", + VERSION, Some("asset-hub-paseo-local"), tempdir()?.path() ) @@ -170,13 +170,12 @@ mod tests { #[tokio::test] async fn system_using_relay_version() -> anyhow::Result<()> { - let version = "v1.12.0"; let expected = Parachain::System; let para_id = 1000; let temp_dir = tempdir()?; let parachain = - system(para_id, expected.binary(), None, None, version, None, temp_dir.path()) + system(para_id, expected.binary(), None, None, VERSION, None, temp_dir.path()) .await? .unwrap(); assert_eq!(para_id, parachain.id); @@ -184,7 +183,7 @@ mod tests { if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: vec![(expected.binary(), None)], @@ -196,13 +195,12 @@ mod tests { #[tokio::test] async fn system_works() -> anyhow::Result<()> { - let version = "v1.12.0"; let expected = Parachain::System; let para_id = 1000; let temp_dir = tempdir()?; let parachain = - system(para_id, expected.binary(), Some(version), None, version, None, temp_dir.path()) + system(para_id, expected.binary(), Some(VERSION), None, VERSION, None, temp_dir.path()) .await? .unwrap(); assert_eq!(para_id, parachain.id); @@ -210,7 +208,7 @@ mod tests { if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: vec![(expected.binary(), None)], @@ -223,7 +221,7 @@ mod tests { #[tokio::test] async fn system_with_chain_spec_generator_works() -> anyhow::Result<()> { let expected = Parachain::System; - let runtime_version = "v1.2.7"; + let runtime_version = "v1.3.3"; let para_id = 1000; let temp_dir = tempdir()?; diff --git a/crates/pop-parachains/src/up/relay.rs b/crates/pop-parachains/src/up/relay.rs index 662e639fd..2390e446a 100644 --- a/crates/pop-parachains/src/up/relay.rs +++ b/crates/pop-parachains/src/up/relay.rs @@ -24,7 +24,7 @@ pub(super) enum RelayChain { Repository = "https://github.com/r0gue-io/polkadot", Binary = "polkadot", TagFormat = "polkadot-{tag}", - Fallback = "v1.12.0" + Fallback = "stable2409" ))] Polkadot, } @@ -131,17 +131,18 @@ mod tests { use super::*; use tempfile::tempdir; + const VERSION: &str = "stable2409"; + #[tokio::test] async fn default_works() -> anyhow::Result<()> { let expected = RelayChain::Polkadot; - let version = "v1.12.0"; let temp_dir = tempdir()?; - let relay = default(Some(version), None, None, temp_dir.path()).await?; + let relay = default(Some(VERSION), None, None, temp_dir.path()).await?; assert!(matches!(relay.binary, Binary::Source { name, source, cache } if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: ["polkadot", "polkadot-execute-worker", "polkadot-prepare-worker"].map(|b| (b, None)).to_vec(), @@ -154,7 +155,7 @@ mod tests { #[tokio::test] async fn default_with_chain_spec_generator_works() -> anyhow::Result<()> { - let runtime_version = "v1.2.7"; + let runtime_version = "v1.3.3"; let temp_dir = tempdir()?; let relay = default(None, Some(runtime_version), Some("paseo-local"), temp_dir.path()).await?; @@ -186,15 +187,14 @@ mod tests { #[tokio::test] async fn from_handles_local_command() -> anyhow::Result<()> { let expected = RelayChain::Polkadot; - let version = "v1.12.0"; let temp_dir = tempdir()?; let relay = - from("./bin-v1.6.0/polkadot", Some(version), None, None, temp_dir.path()).await?; + from("./bin-stable2409/polkadot", Some(VERSION), None, None, temp_dir.path()).await?; assert!(matches!(relay.binary, Binary::Source { name, source, cache } if name == expected.binary() && source == Source::GitHub(ReleaseArchive { owner: "r0gue-io".to_string(), repository: "polkadot".to_string(), - tag: Some(version.to_string()), + tag: Some(VERSION.to_string()), tag_format: Some("polkadot-{tag}".to_string()), archive: format!("{name}-{}.tar.gz", target()?), contents: ["polkadot", "polkadot-execute-worker", "polkadot-prepare-worker"].map(|b| (b, None)).to_vec(), diff --git a/crates/pop-parachains/src/utils/helpers.rs b/crates/pop-parachains/src/utils/helpers.rs index bd39eec9e..f38d7bce5 100644 --- a/crates/pop-parachains/src/utils/helpers.rs +++ b/crates/pop-parachains/src/utils/helpers.rs @@ -33,7 +33,8 @@ pub fn is_initial_endowment_valid(initial_endowment: &str) -> bool { initial_endowment.parse::().is_ok() || is_valid_bitwise_left_shift(initial_endowment).is_ok() } -// Auxiliar method to check if the endowment input with a shift left (1u64 << 60) format is valid. + +// Auxiliary method to check if the endowment input with a shift left (1u64 << 60) format is valid. // Parse the self << rhs format and check the shift left operation is valid. fn is_valid_bitwise_left_shift(initial_endowment: &str) -> Result { let v: Vec<&str> = initial_endowment.split(" << ").collect(); diff --git a/deny.toml b/deny.toml index 5c295de57..b1e67ce44 100644 --- a/deny.toml +++ b/deny.toml @@ -20,8 +20,10 @@ allow = [ "GPL-3.0", "MIT", "MPL-2.0", + "Unicode-3.0", "Unicode-DFS-2016", - "Unlicense" + "Unlicense", + "Zlib" ] confidence-threshold = 0.93 @@ -34,4 +36,4 @@ name = "ring" expression = "ISC AND MIT AND OpenSSL" license-files = [ { path = "LICENSE", hash = 0xbd0eed23 }, -] \ No newline at end of file +] diff --git a/tests/networks/kusama+asset-hub.toml b/tests/networks/kusama+asset-hub.toml new file mode 100644 index 000000000..c652bd841 --- /dev/null +++ b/tests/networks/kusama+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/kusama+asset-hub.toml + +[relaychain] +chain = "kusama-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-kusama-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/paseo+asset-hub.toml b/tests/networks/paseo+asset-hub.toml new file mode 100644 index 000000000..a75719376 --- /dev/null +++ b/tests/networks/paseo+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/paseo+asset-hub.toml + +[relaychain] +chain = "paseo-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-paseo-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/polkadot+asset-hub.toml b/tests/networks/polkadot+asset-hub.toml new file mode 100644 index 000000000..9cf6735b2 --- /dev/null +++ b/tests/networks/polkadot+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/polkadot+asset-hub.toml + +[relaychain] +chain = "polkadot-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-polkadot-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/pop.toml b/tests/networks/pop.toml index 9ad7c871d..643f1a0b5 100644 --- a/tests/networks/pop.toml +++ b/tests/networks/pop.toml @@ -24,4 +24,16 @@ default_command = "pop-node" [[parachains.collators]] name = "pop" -args = ["-lruntime::contracts=debug"] \ No newline at end of file +args = ["-lruntime::contracts=debug"] + +[[hrmp_channels]] +sender = 1000 +recipient = 4385 +max_capacity = 1000 +max_message_size = 5000 + +[[hrmp_channels]] +sender = 4385 +recipient = 1000 +max_capacity = 1000 +max_message_size = 8000 \ No newline at end of file diff --git a/tests/networks/westend+asset-hub.toml b/tests/networks/westend+asset-hub.toml new file mode 100644 index 000000000..3404173f8 --- /dev/null +++ b/tests/networks/westend+asset-hub.toml @@ -0,0 +1,19 @@ +# pop up parachain -f ./tests/networks/westend+asset-hub.toml + +[relaychain] +chain = "westend-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true + +[[parachains]] +id = 1000 +chain = "asset-hub-westend-local" + +[[parachains.collators]] +name = "asset-hub" \ No newline at end of file diff --git a/tests/networks/westend.toml b/tests/networks/westend.toml new file mode 100644 index 000000000..7bdb66bdd --- /dev/null +++ b/tests/networks/westend.toml @@ -0,0 +1,12 @@ +# pop up parachain -f ./tests/networks/westend.toml + +[relaychain] +chain = "westend-local" + +[[relaychain.nodes]] +name = "alice" +validator = true + +[[relaychain.nodes]] +name = "bob" +validator = true
