(temp_contract_dir: P, contract_file: P, metadata_file: P) -> Result<()> 28 | where 29 | P: AsRef, 30 | { 31 | // Create a target directory 32 | let target_contract_dir = temp_contract_dir.as_ref().join("target"); 33 | create_dir(&target_contract_dir)?; 34 | create_dir(target_contract_dir.join("ink"))?; 35 | // Copy a mocked testing.contract and testing.json files inside the target directory 36 | copy(contract_file, target_contract_dir.join("ink/testing.contract"))?; 37 | copy(metadata_file, target_contract_dir.join("ink/testing.json"))?; 38 | Ok(()) 39 | } 40 | -------------------------------------------------------------------------------- /crates/pop-contracts/src/utils/map_account.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use crate::{errors::Error, DefaultEnvironment}; 4 | use contract_extrinsics_inkv6::{ExtrinsicOpts, MapAccountCommandBuilder, MapAccountExec}; 5 | use pop_common::{DefaultConfig, Keypair}; 6 | use subxt::{ext::scale_encode::EncodeAsType, utils::H160}; 7 | 8 | /// A helper struct for performing account mapping operations. 9 | pub struct AccountMapper { 10 | map_exec: MapAccountExec, 11 | } 12 | 13 | impl AccountMapper { 14 | /// Creates a new `AccountMapper` instance. 15 | /// 16 | /// # Arguments 17 | /// * `extrinsic_opts` - Options used to build and submit a contract extrinsic. 18 | pub async fn new( 19 | extrinsic_opts: &ExtrinsicOpts, 20 | ) -> Result { 21 | let map_exec = MapAccountCommandBuilder::new(extrinsic_opts.clone()).done().await?; 22 | Ok(Self { map_exec }) 23 | } 24 | 25 | /// Checks whether the account needs to be mapped by performing a dry run. 26 | pub async fn needs_mapping(&self) -> Result { 27 | Ok(self.map_exec.map_account_dry_run().await.is_ok()) 28 | } 29 | 30 | /// Performs the actual account mapping. 31 | pub async fn map_account(&self) -> Result { 32 | let result = self 33 | .map_exec 34 | .map_account() 35 | .await 36 | .map_err(|e| Error::MapAccountError(e.to_string()))?; 37 | Ok(result.address) 38 | } 39 | } 40 | 41 | // Create a call to `Revive::map_account`. 42 | #[derive(Debug, EncodeAsType)] 43 | #[encode_as_type(crate_path = "subxt::ext::scale_encode")] 44 | pub(crate) struct MapAccount {} 45 | 46 | impl MapAccount { 47 | // Construct an empty `MapAccount` payload. 48 | pub(crate) fn new() -> Self { 49 | Self {} 50 | } 51 | // Create a call to `Revive::map_account` with no arguments. 52 | pub(crate) fn build(self) -> subxt::tx::DefaultPayload { 53 | subxt::tx::DefaultPayload::new("Revive", "map_account", self) 54 | } 55 | } 56 | 57 | #[cfg(test)] 58 | mod tests { 59 | use super::*; 60 | use crate::{ 61 | contracts_node_generator, mock_build_process, new_environment, run_contracts_node, 62 | }; 63 | use anyhow::Result; 64 | use contract_extrinsics_inkv6::ExtrinsicOptsBuilder; 65 | use pop_common::{find_free_port, parse_h160_account, set_executable_permission}; 66 | use std::{env, process::Command}; 67 | use subxt_signer::sr25519::dev; 68 | use url::Url; 69 | 70 | #[tokio::test] 71 | async fn map_account_works() -> Result<()> { 72 | let random_port = find_free_port(None); 73 | let localhost_url = format!("ws://127.0.0.1:{}", random_port); 74 | let temp_dir = new_environment("testing")?; 75 | let current_dir = env::current_dir().expect("Failed to get current directory"); 76 | mock_build_process( 77 | temp_dir.path().join("testing"), 78 | current_dir.join("./tests/files/testing.contract"), 79 | current_dir.join("./tests/files/testing.json"), 80 | )?; 81 | // Run the process contracts-node for the test. 82 | let cache = temp_dir.path().join(""); 83 | let binary = contracts_node_generator(cache, None).await?; 84 | binary.source(false, &(), true).await?; 85 | set_executable_permission(binary.path())?; 86 | let process = run_contracts_node(binary.path(), None, random_port).await?; 87 | // Alice is mapped when running the contracts-node. 88 | let signer = dev::bob(); 89 | let extrinsic_opts: ExtrinsicOpts = 90 | ExtrinsicOptsBuilder::new(signer) 91 | .file(Some(current_dir.join("./tests/files/testing.contract"))) 92 | .url(Url::parse(&localhost_url)?) 93 | .done(); 94 | let map = AccountMapper::new(&extrinsic_opts).await?; 95 | assert!(map.needs_mapping().await?); 96 | 97 | let address = map.map_account().await?; 98 | assert_eq!(address, parse_h160_account("0x41dccbd49b26c50d34355ed86ff0fa9e489d1e01")?); 99 | 100 | assert!(!map.needs_mapping().await?); 101 | 102 | // Stop the process contracts-node after test. 103 | Command::new("kill") 104 | .args(["-s", "TERM", &process.id().to_string()]) 105 | .spawn()? 106 | .wait()?; 107 | Ok(()) 108 | } 109 | } 110 | -------------------------------------------------------------------------------- /crates/pop-contracts/src/utils/mod.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use crate::{errors::Error, Bytes, DefaultEnvironment, Environment}; 4 | use std::{ 5 | path::{Path, PathBuf}, 6 | str::FromStr, 7 | }; 8 | #[cfg(feature = "v5")] 9 | use { 10 | contract_build::{util::decode_hex, ManifestPath}, 11 | contract_extrinsics::BalanceVariant, 12 | }; 13 | #[cfg(feature = "v6")] 14 | use { 15 | contract_build_inkv6::{util::decode_hex, ManifestPath}, 16 | contract_extrinsics_inkv6::BalanceVariant, 17 | }; 18 | 19 | /// Module for account mapping functionality. 20 | #[cfg(feature = "v6")] 21 | pub mod map_account; 22 | pub mod metadata; 23 | 24 | /// Retrieves the manifest path for a contract project. 25 | /// 26 | /// # Arguments 27 | /// * `path` - An optional path to the project directory. 28 | pub fn get_manifest_path(path: Option<&Path>) -> Result { 29 | if let Some(path) = path { 30 | let full_path = PathBuf::from(path.to_string_lossy().to_string() + "/Cargo.toml"); 31 | ManifestPath::try_from(Some(full_path)) 32 | .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) 33 | } else { 34 | ManifestPath::try_from(path.as_ref()) 35 | .map_err(|e| Error::ManifestPath(format!("Failed to get manifest path: {}", e))) 36 | } 37 | } 38 | 39 | /// Parses a balance value from a string representation. 40 | /// 41 | /// # Arguments 42 | /// * `balance` - A string representing the balance value to parse. 43 | pub fn parse_balance( 44 | balance: &str, 45 | ) -> Result::Balance>, Error> { 46 | BalanceVariant::from_str(balance).map_err(|e| Error::BalanceParsing(format!("{}", e))) 47 | } 48 | 49 | /// Parse hex encoded bytes. 50 | /// 51 | /// # Arguments 52 | /// * `input` - A string containing hex-encoded bytes. 53 | pub fn parse_hex_bytes(input: &str) -> Result { 54 | let bytes = decode_hex(input).map_err(|e| Error::HexParsing(format!("{}", e)))?; 55 | Ok(bytes.into()) 56 | } 57 | 58 | /// Canonicalizes the given path to ensure consistency and resolve any symbolic links. 59 | /// 60 | /// # Arguments 61 | /// * `target` - A reference to the `Path` to be canonicalized. 62 | pub fn canonicalized_path(target: &Path) -> Result { 63 | // Canonicalize the target path to ensure consistency and resolve any symbolic links. 64 | target 65 | .canonicalize() 66 | // If an I/O error occurs during canonicalization, convert it into an Error enum variant. 67 | .map_err(Error::IO) 68 | } 69 | 70 | #[cfg(test)] 71 | mod tests { 72 | use super::*; 73 | use anyhow::Result; 74 | use std::fs; 75 | 76 | fn setup_test_environment() -> Result { 77 | let temp_dir = tempfile::tempdir().expect("Could not create temp dir"); 78 | let temp_contract_dir = temp_dir.path().join("test_contract"); 79 | fs::create_dir(&temp_contract_dir)?; 80 | crate::create_smart_contract( 81 | "test_contract", 82 | temp_contract_dir.as_path(), 83 | &crate::Contract::Standard, 84 | )?; 85 | Ok(temp_dir) 86 | } 87 | 88 | #[test] 89 | fn test_get_manifest_path() -> Result<(), Error> { 90 | let temp_dir = setup_test_environment()?; 91 | get_manifest_path(Some(&PathBuf::from(temp_dir.path().join("test_contract"))))?; 92 | Ok(()) 93 | } 94 | 95 | #[test] 96 | fn test_canonicalized_path() -> Result<(), Error> { 97 | let temp_dir = tempfile::tempdir()?; 98 | // Error case 99 | let error_directory = canonicalized_path(&temp_dir.path().join("my_directory")); 100 | assert!(error_directory.is_err()); 101 | // Success case 102 | canonicalized_path(temp_dir.path())?; 103 | Ok(()) 104 | } 105 | 106 | #[test] 107 | fn parse_balance_works() -> Result<(), Error> { 108 | let balance = parse_balance("100000")?; 109 | assert_eq!(balance, BalanceVariant::Default(100000)); 110 | Ok(()) 111 | } 112 | 113 | #[test] 114 | fn parse_balance_fails_wrong_balance() -> Result<(), Error> { 115 | assert!(matches!(parse_balance("wrongbalance"), Err(super::Error::BalanceParsing(..)))); 116 | Ok(()) 117 | } 118 | 119 | #[test] 120 | fn parse_hex_bytes_works() -> Result<(), Error> { 121 | let input_in_hex = "48656c6c6f"; 122 | let result = parse_hex_bytes(input_in_hex)?; 123 | assert_eq!(result, Bytes(vec![72, 101, 108, 108, 111])); 124 | Ok(()) 125 | } 126 | 127 | #[test] 128 | fn parse_hex_bytes_fails_wrong_input() -> Result<()> { 129 | assert!(matches!(parse_hex_bytes("wronghexvalue"), Err(Error::HexParsing(..)))); 130 | Ok(()) 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /crates/pop-contracts/tests/files/testing.polkavm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/crates/pop-contracts/tests/files/testing.polkavm -------------------------------------------------------------------------------- /crates/pop-contracts/tests/files/testing.wasm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/crates/pop-contracts/tests/files/testing.wasm -------------------------------------------------------------------------------- /crates/pop-parachains/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "pop-parachains" 3 | description = "Library for generating, building and running parachains." 4 | license = "Apache-2.0" 5 | documentation = "https://docs.rs/pop-parachains/latest/pop_parachains" 6 | edition.workspace = true 7 | readme = "README.md" 8 | repository.workspace = true 9 | version.workspace = true 10 | 11 | [dependencies] 12 | anyhow.workspace = true 13 | clap.workspace = true 14 | duct.workspace = true 15 | glob.workspace = true 16 | serde_json.workspace = true 17 | strum.workspace = true 18 | strum_macros.workspace = true 19 | subxt-signer.workspace = true 20 | subxt.workspace = true 21 | tempfile.workspace = true 22 | thiserror.workspace = true 23 | tokio.workspace = true 24 | url.workspace = true 25 | 26 | askama.workspace = true 27 | indexmap.workspace = true 28 | scale.workspace = true 29 | scale-info.workspace = true 30 | scale-value.workspace = true 31 | sp-core.workspace = true 32 | srtool-lib.workspace = true 33 | symlink.workspace = true 34 | toml_edit.workspace = true 35 | walkdir.workspace = true 36 | # Zombienet 37 | zombienet-configuration.workspace = true 38 | zombienet-sdk.workspace = true 39 | 40 | # Benchmarking 41 | cumulus-primitives-proof-size-hostfunction.workspace = true 42 | frame-benchmarking-cli.workspace = true 43 | sc-chain-spec.workspace = true 44 | serde.workspace = true 45 | sp-runtime.workspace = true 46 | sp-statement-store.workspace = true 47 | 48 | # Try Runtime 49 | frame-try-runtime = { workspace = true, features = ["try-runtime"] } 50 | sc-cli.workspace = true 51 | sp-version.workspace = true 52 | 53 | # Pop 54 | pop-common = { path = "../pop-common", version = "0.8.1" } 55 | 56 | [dev-dependencies] 57 | # Used in doc tests. 58 | tokio-test.workspace = true 59 | -------------------------------------------------------------------------------- /crates/pop-parachains/LICENSE: -------------------------------------------------------------------------------- 1 | ../../LICENSE -------------------------------------------------------------------------------- /crates/pop-parachains/askama.toml: -------------------------------------------------------------------------------- 1 | [general] 2 | # Directories to search for templates, relative to the crate root. 3 | dirs = ["templates"] 4 | # Unless you add a `-` in a block, whitespace characters won't be trimmed. 5 | whitespace = "preserve" 6 | default_syntax = "substrate" 7 | 8 | [[syntax]] 9 | name = "substrate" 10 | block_start = "{{" 11 | block_end = "}}" 12 | comment_start = "#{" 13 | comment_end = "}#" 14 | expr_start = "^^" 15 | expr_end = "^^" 16 | 17 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/accounts.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use scale::Encode; 4 | use sp_core::crypto::AccountId32; 5 | #[cfg(test)] 6 | use sp_core::crypto::Ss58Codec; 7 | 8 | /// Calculate the sovereign account of a sibling rollup - i.e., from the context of a rollup. 9 | /// 10 | /// # Arguments 11 | /// * `id` - The rollup identifier. 12 | pub(crate) fn sibl(id: u32) -> AccountId32 { 13 | sovereign_account(id, b"sibl") 14 | } 15 | 16 | /// Calculate the sovereign account of a child rollup - i.e., from the context of a relay chain. 17 | /// 18 | /// # Arguments 19 | /// * `id` - The rollup identifier. 20 | #[allow(dead_code)] 21 | pub(crate) fn para(id: u32) -> AccountId32 { 22 | sovereign_account(id, b"para") 23 | } 24 | 25 | /// Calculate the sovereign account of a rollup. 26 | /// 27 | /// # Arguments 28 | /// * `id` - The rollup identifier. 29 | fn sovereign_account(id: u32, prefix: &[u8; 4]) -> AccountId32 { 30 | let mut account = [0u8; 32]; 31 | account[..4].copy_from_slice(prefix); 32 | let mut x = &mut account[4..8]; 33 | id.encode_to(&mut x); 34 | account.into() 35 | } 36 | 37 | #[test] 38 | fn sibling_rollup_sovereign_account_works() { 39 | let account = sibl(4_001); 40 | assert_eq!(account.to_ss58check(), "5Eg2fnt8cGL5CBhRRhi59abAwb3SPoAdPJpN9qY7bQqpzpf6"); 41 | } 42 | 43 | #[test] 44 | fn child_rollup_sovereign_account_works() { 45 | let account = para(4_001); 46 | assert_eq!(account.to_ss58check(), "5Ec4AhPKXY9B4ayGshkz2wFMh7N8gP7XKfAvtt1cigpG9FkJ"); 47 | } 48 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/bench/binary.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use pop_common::{ 4 | git::GitHub, 5 | polkadot_sdk::sort_by_latest_stable_version, 6 | sourcing::{ 7 | filters::prefix, 8 | traits::{ 9 | enums::{Source as _, *}, 10 | Source as SourceT, 11 | }, 12 | ArchiveFileSpec, Binary, 13 | GitHub::*, 14 | Source, 15 | }, 16 | target, Error, 17 | }; 18 | use std::path::PathBuf; 19 | use strum_macros::EnumProperty; 20 | 21 | #[derive(Debug, EnumProperty, PartialEq)] 22 | pub(super) enum BenchmarkingCli { 23 | #[strum(props( 24 | Repository = "https://github.com/r0gue-io/polkadot", 25 | Binary = "frame-omni-bencher", 26 | TagPattern = "polkadot-{version}", 27 | Fallback = "stable2412" 28 | ))] 29 | OmniBencher, 30 | } 31 | 32 | impl SourceT for BenchmarkingCli { 33 | type Error = Error; 34 | /// Defines the source of the binary required for benchmarking. 35 | fn source(&self) -> Result { 36 | // Source from GitHub release asset 37 | let repo = GitHub::parse(self.repository())?; 38 | let binary = self.binary(); 39 | Ok(Source::GitHub(ReleaseArchive { 40 | owner: repo.org, 41 | repository: repo.name, 42 | tag: None, 43 | tag_pattern: self.tag_pattern().map(|t| t.into()), 44 | prerelease: false, 45 | version_comparator: sort_by_latest_stable_version, 46 | fallback: self.fallback().into(), 47 | archive: format!("{binary}-{}.tar.gz", target()?), 48 | contents: vec![ArchiveFileSpec::new(binary.into(), Some(binary.into()), true)], 49 | latest: None, 50 | })) 51 | } 52 | } 53 | 54 | /// Generate the source of the `frame-omni-bencher` binary on the remote repository. 55 | /// 56 | /// # Arguments 57 | /// * `cache` - The path to the directory where the binary should be cached. 58 | /// * `version` - An optional version string. If `None`, the latest available version is used. 59 | pub async fn omni_bencher_generator( 60 | cache: PathBuf, 61 | version: Option<&str>, 62 | ) -> Result { 63 | let cli = BenchmarkingCli::OmniBencher; 64 | let name = cli.binary().to_string(); 65 | let source = cli 66 | .source()? 67 | .resolve(&name, version, cache.as_path(), |f| prefix(f, &name)) 68 | .await 69 | .into(); 70 | let binary = Binary::Source { name, source, cache: cache.to_path_buf() }; 71 | Ok(binary) 72 | } 73 | 74 | #[cfg(test)] 75 | mod tests { 76 | use super::*; 77 | use tempfile::tempdir; 78 | 79 | #[tokio::test] 80 | async fn omni_bencher_generator_works() -> Result<(), Error> { 81 | let temp_dir = tempdir()?; 82 | let temp_dir_path = temp_dir.into_path(); 83 | let version = "polkadot-stable2412-4"; 84 | let binary = omni_bencher_generator(temp_dir_path.clone(), Some(version)).await?; 85 | assert!(matches!(binary, Binary::Source { name: _, source, cache } 86 | if source == Source::GitHub(ReleaseArchive { 87 | owner: "r0gue-io".to_string(), 88 | repository: "polkadot".to_string(), 89 | tag: Some(version.to_string()), 90 | tag_pattern: Some("polkadot-{version}".into()), 91 | prerelease: false, 92 | version_comparator: sort_by_latest_stable_version, 93 | fallback: "stable2412".to_string(), 94 | archive: format!("frame-omni-bencher-{}.tar.gz", target()?), 95 | contents: ["frame-omni-bencher"].map(|b| ArchiveFileSpec::new(b.into(), Some(b.into()), true)).to_vec(), 96 | latest: binary.latest().map(|l| l.to_string()), 97 | }).into() && 98 | cache == temp_dir_path.as_path() 99 | )); 100 | Ok(()) 101 | } 102 | } 103 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/generator/mod.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | pub mod pallet; 4 | pub mod parachain; 5 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/generator/parachain.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use askama::Template; 4 | 5 | #[derive(Template)] 6 | #[template(path = "base/chain_spec.templ", escape = "none")] 7 | pub(crate) struct ChainSpec { 8 | pub(crate) token_symbol: String, 9 | pub(crate) decimals: u8, 10 | pub(crate) initial_endowment: String, 11 | // Identifies the template used to generate the chain. 12 | pub(crate) based_on: String, 13 | } 14 | 15 | #[derive(Template)] 16 | #[template(path = "base/network.templ", escape = "none")] 17 | pub(crate) struct Network { 18 | pub(crate) node: String, 19 | } 20 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/lib.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | #![doc = include_str!("../README.md")] 4 | 5 | mod accounts; 6 | /// Provides functionality for benchmarking. 7 | pub mod bench; 8 | mod build; 9 | /// Provides functionality to construct, encode, sign, and submit chain extrinsics. 10 | mod call; 11 | /// Deployment providers' metadata and utility functions. 12 | mod deployer_providers; 13 | mod errors; 14 | mod generator; 15 | mod new_pallet; 16 | mod new_parachain; 17 | /// A registry of parachains. 18 | pub mod registry; 19 | mod relay; 20 | mod templates; 21 | mod traits; 22 | /// Provides functionality for testing runtime upgrades. 23 | pub mod try_runtime; 24 | /// Provides functionality for launching a local network. 25 | pub mod up; 26 | mod utils; 27 | 28 | pub use bench::{ 29 | binary::*, generate_binary_benchmarks, generate_omni_bencher_benchmarks, 30 | generate_pallet_benchmarks, get_preset_names, get_runtime_path, load_pallet_extrinsics, 31 | BenchmarkingCliCommand, GenesisBuilderPolicy, PalletExtrinsicsRegistry, 32 | GENESIS_BUILDER_DEV_PRESET, 33 | }; 34 | pub use build::{ 35 | binary_path, build_parachain, build_project, export_wasm_file, generate_genesis_state_file, 36 | generate_plain_chain_spec, generate_raw_chain_spec, is_supported, runtime, 37 | runtime::{ContainerEngine, DeterministicBuilder}, 38 | runtime_binary_path, ChainSpec, 39 | }; 40 | pub use call::{ 41 | construct_extrinsic, construct_proxy_extrinsic, construct_sudo_extrinsic, decode_call_data, 42 | encode_call_data, 43 | metadata::{ 44 | action::{supported_actions, Action}, 45 | find_dispatchable_by_name, find_pallet_by_name, 46 | params::Param, 47 | parse_chain_metadata, Function, Pallet, 48 | }, 49 | parse_and_format_events, set_up_client, sign_and_submit_extrinsic, submit_signed_extrinsic, 50 | CallData, 51 | }; 52 | pub use deployer_providers::{DeploymentProvider, SupportedChains}; 53 | pub use errors::Error; 54 | pub use indexmap::IndexSet; 55 | pub use new_pallet::{create_pallet_template, new_pallet_options::*, TemplatePalletConfig}; 56 | pub use new_parachain::instantiate_template_dir; 57 | pub use relay::{clear_dmpq, RelayChain, Reserved}; 58 | pub use try_runtime::{ 59 | binary::*, parse, parse_try_state_string, run_try_runtime, shared_parameters::*, state, 60 | try_state_details, try_state_label, upgrade_checks_details, TryRuntimeCliCommand, 61 | }; 62 | // External export from subxt. 63 | pub use subxt::{ 64 | blocks::ExtrinsicEvents, 65 | tx::{DynamicPayload, Payload}, 66 | OnlineClient, SubstrateConfig, 67 | }; 68 | pub use templates::{Config, Parachain, Provider}; 69 | pub use utils::helpers::is_initial_endowment_valid; 70 | /// Information about the Node. External export from Zombienet-SDK. 71 | pub use zombienet_sdk::NetworkNode; 72 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/new_pallet/new_pallet_options.rs: -------------------------------------------------------------------------------- 1 | use clap::ValueEnum; 2 | use strum_macros::{EnumIter, EnumMessage}; 3 | 4 | /// This enum is used to register from the CLI which types that are kind of usual in config traits 5 | /// are included in the pallet 6 | #[derive(Debug, Copy, Clone, PartialEq, EnumIter, EnumMessage, ValueEnum)] 7 | pub enum TemplatePalletConfigCommonTypes { 8 | /// This type will enable your pallet to emit events. 9 | #[strum( 10 | message = "RuntimeEvent", 11 | detailed_message = "This type will enable your pallet to emit events." 12 | )] 13 | RuntimeEvent, 14 | /// This type will be helpful if your pallet needs to deal with the outer RuntimeOrigin enum, 15 | /// or if your pallet needs to use custom origins. Note: If you have run the command using -o, 16 | /// this type will be added anyway. 17 | #[strum( 18 | message = "RuntimeOrigin", 19 | detailed_message = "This type will be helpful if your pallet needs to deal with the outer RuntimeOrigin enum, or if your pallet needs to use custom origins. Note: If you have run the command using -o, this type will be added anyway." 20 | )] 21 | RuntimeOrigin, 22 | /// This type will allow your pallet to interact with the native currency of the blockchain. 23 | #[strum( 24 | message = "Currency", 25 | detailed_message = "This type will allow your pallet to interact with the native currency of the blockchain." 26 | )] 27 | Currency, 28 | } 29 | 30 | /// This enum is used to determine which storage shape has a storage item in the pallet 31 | #[derive(Debug, Copy, Clone, PartialEq, EnumIter, EnumMessage, ValueEnum)] 32 | pub enum TemplatePalletStorageTypes { 33 | /// A storage value is a single value of a given type stored on-chain. 34 | #[strum( 35 | message = "StorageValue", 36 | detailed_message = "A storage value is a single value of a given type stored on-chain." 37 | )] 38 | StorageValue, 39 | /// A storage map is a mapping of keys to values of a given type stored on-chain. 40 | #[strum( 41 | message = "StorageMap", 42 | detailed_message = "A storage map is a mapping of keys to values of a given type stored on-chain." 43 | )] 44 | StorageMap, 45 | /// A wrapper around a StorageMap and a StorageValue (with the value being u32) to keep track 46 | /// of how many items are in a map. 47 | #[strum( 48 | message = "CountedStorageMap", 49 | detailed_message = "A wrapper around a StorageMap and a StorageValue (with the value being u32) to keep track of how many items are in a map." 50 | )] 51 | CountedStorageMap, 52 | /// This structure associates a pair of keys with a value of a specified type stored on-chain. 53 | #[strum( 54 | message = "StorageDoubleMap", 55 | detailed_message = "This structure associates a pair of keys with a value of a specified type stored on-chain." 56 | )] 57 | StorageDoubleMap, 58 | /// This structure associates an arbitrary number of keys with a value of a specified type 59 | /// stored on-chain. 60 | #[strum( 61 | message = "StorageNMap", 62 | detailed_message = "This structure associates an arbitrary number of keys with a value of a specified type stored on-chain." 63 | )] 64 | StorageNMap, 65 | /// A wrapper around a StorageNMap and a StorageValue (with the value being u32) to keep track 66 | /// of how many items are in a map. 67 | #[strum( 68 | message = "CountedStorageNMap", 69 | detailed_message = "A wrapper around a StorageNMap and a StorageValue (with the value being u32) to keep track of how many items are in a map." 70 | )] 71 | CountedStorageNMap, 72 | } 73 | 74 | /// This enum is used to register from the CLI which options are selected by the user to be included 75 | /// in the pallet. 76 | #[derive(Debug, Copy, Clone, PartialEq, EnumIter, EnumMessage)] 77 | pub enum TemplatePalletOptions { 78 | /// Uses a default configuration for the pallet's config trait. 79 | #[strum( 80 | message = "DefaultConfig", 81 | detailed_message = "Use a default configuration for your config trait." 82 | )] 83 | DefaultConfig, 84 | /// Adds a genesis config to the pallet. 85 | #[strum(message = "GenesisConfig", detailed_message = "Add a genesis config to your pallet.")] 86 | GenesisConfig, 87 | /// Adds a custom origin to the pallet. 88 | #[strum(message = "Custom Origin", detailed_message = "Add a custom origin to your pallet.")] 89 | CustomOrigin, 90 | } 91 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/new_parachain.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use crate::{ 4 | generator::parachain::{ChainSpec, Network}, 5 | utils::helpers::{sanitize, write_to_file}, 6 | Config, Parachain, Provider, 7 | }; 8 | use anyhow::Result; 9 | use pop_common::{ 10 | git::Git, 11 | templates::{extractor::extract_template_files, Template, Type}, 12 | }; 13 | use std::{fs, path::Path}; 14 | use walkdir::WalkDir; 15 | 16 | /// Create a new parachain. 17 | /// 18 | /// # Arguments 19 | /// 20 | /// * `template` - template to generate the parachain from. 21 | /// * `target` - location where the parachain will be created. 22 | /// * `tag_version` - version to use (`None` to use latest). 23 | /// * `config` - customization values to include in the new parachain. 24 | pub fn instantiate_template_dir( 25 | template: &Parachain, 26 | target: &Path, 27 | tag_version: Option, 28 | config: Config, 29 | ) -> Result> { 30 | sanitize(target)?; 31 | 32 | if Provider::Pop.provides(template) || template == &Parachain::ParityGeneric { 33 | return instantiate_standard_template(template, target, config, tag_version); 34 | } 35 | if Provider::OpenZeppelin.provides(template) { 36 | return instantiate_openzeppelin_template(template, target, tag_version); 37 | } 38 | let tag = Git::clone_and_degit(template.repository_url()?, target, tag_version)?; 39 | Ok(tag) 40 | } 41 | 42 | pub fn instantiate_standard_template( 43 | template: &Parachain, 44 | target: &Path, 45 | config: Config, 46 | tag_version: Option, 47 | ) -> Result> { 48 | let temp_dir = ::tempfile::TempDir::new_in(std::env::temp_dir())?; 49 | let source = temp_dir.path(); 50 | 51 | let tag = Git::clone_and_degit(template.repository_url()?, source, tag_version)?; 52 | 53 | for entry in WalkDir::new(source) { 54 | let entry = entry?; 55 | 56 | let source_path = entry.path(); 57 | let destination_path = target.join(source_path.strip_prefix(source)?); 58 | 59 | if entry.file_type().is_dir() { 60 | fs::create_dir_all(&destination_path)?; 61 | } else { 62 | fs::copy(source_path, &destination_path)?; 63 | } 64 | } 65 | let chainspec = ChainSpec { 66 | token_symbol: config.symbol, 67 | decimals: config.decimals, 68 | initial_endowment: config.initial_endowment, 69 | based_on: template.to_string(), 70 | }; 71 | use askama::Template; 72 | write_to_file( 73 | &target.join("node/src/chain_spec.rs"), 74 | chainspec.render().expect("infallible").as_ref(), 75 | )?; 76 | // Add network configuration 77 | let network = Network { node: "parachain-template-node".into() }; 78 | write_to_file(&target.join("network.toml"), network.render().expect("infallible").as_ref())?; 79 | Ok(tag) 80 | } 81 | 82 | pub fn instantiate_openzeppelin_template( 83 | template: &Parachain, 84 | target: &Path, 85 | tag_version: Option, 86 | ) -> Result> { 87 | let temp_dir = ::tempfile::TempDir::new_in(std::env::temp_dir())?; 88 | let source = temp_dir.path(); 89 | 90 | let tag = Git::clone_and_degit(template.repository_url()?, source, tag_version)?; 91 | let template_name = template.template_name_without_provider(); 92 | extract_template_files(template_name, temp_dir.path(), target, None)?; 93 | Ok(tag) 94 | } 95 | 96 | #[cfg(test)] 97 | mod tests { 98 | use super::*; 99 | use anyhow::Result; 100 | use std::{env::current_dir, fs}; 101 | 102 | fn setup_template_and_instantiate() -> Result { 103 | let temp_dir = tempfile::tempdir().expect("Failed to create temp dir"); 104 | let config = Config { 105 | symbol: "DOT".to_string(), 106 | decimals: 18, 107 | initial_endowment: "1000000".to_string(), 108 | }; 109 | instantiate_standard_template(&Parachain::Standard, temp_dir.path(), config, None)?; 110 | Ok(temp_dir) 111 | } 112 | 113 | #[test] 114 | fn test_parachain_instantiate_standard_template() -> Result<()> { 115 | let temp_dir = 116 | setup_template_and_instantiate().expect("Failed to setup template and instantiate"); 117 | 118 | // Verify that the generated chain_spec.rs file contains the expected content 119 | let generated_file_content = 120 | fs::read_to_string(temp_dir.path().join("node/src/chain_spec.rs")) 121 | .expect("Failed to read file"); 122 | assert!(generated_file_content 123 | .contains("properties.insert(\"tokenSymbol\".into(), \"DOT\".into());")); 124 | assert!(generated_file_content 125 | .contains("properties.insert(\"tokenDecimals\".into(), 18.into());")); 126 | assert!(generated_file_content.contains("1000000")); 127 | 128 | // Verify network.toml contains expected content 129 | let generated_file_content = 130 | fs::read_to_string(temp_dir.path().join("network.toml")).expect("Failed to read file"); 131 | let expected_file_content = 132 | fs::read_to_string(current_dir()?.join("./templates/base/network.templ")) 133 | .expect("Failed to read file"); 134 | assert_eq!( 135 | generated_file_content, 136 | expected_file_content.replace("^^node^^", "parachain-template-node") 137 | ); 138 | 139 | Ok(()) 140 | } 141 | 142 | #[test] 143 | fn test_parachain_instantiate_openzeppelin_template() -> Result<()> { 144 | let temp_dir = tempfile::tempdir().expect("Failed to create temp dir"); 145 | instantiate_openzeppelin_template(&Parachain::OpenZeppelinEVM, temp_dir.path(), None)?; 146 | 147 | let node_manifest = 148 | pop_common::manifest::from_path(Some(&temp_dir.path().join("node/Cargo.toml"))) 149 | .expect("Failed to read file"); 150 | assert_eq!("evm-template-node", node_manifest.package().name()); 151 | 152 | let runtime_manifest = 153 | pop_common::manifest::from_path(Some(&temp_dir.path().join("runtime/Cargo.toml"))) 154 | .expect("Failed to read file"); 155 | assert_eq!("evm-runtime-template", runtime_manifest.package().name()); 156 | 157 | Ok(()) 158 | } 159 | } 160 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/registry/pop.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use super::{traits::Requires, *}; 4 | use crate::{ 5 | accounts, 6 | traits::{Args, Binary}, 7 | Error, 8 | }; 9 | use pop_common::{ 10 | polkadot_sdk::sort_by_latest_semantic_version, 11 | sourcing::{traits::Source as SourceT, ArchiveFileSpec, GitHub::ReleaseArchive, Source}, 12 | target, 13 | }; 14 | use serde_json::{json, Map, Value}; 15 | use sp_core::crypto::Ss58Codec; 16 | use std::collections::HashMap; 17 | 18 | /// Pop Network makes it easy for smart contract developers to use the power of Polkadot. 19 | #[derive(Clone)] 20 | pub struct Pop(Rollup); 21 | impl Pop { 22 | /// A new instance of Pop. 23 | /// 24 | /// # Arguments 25 | /// * `id` - The rollup identifier. 26 | /// * `chain` - The identifier of the chain, as used by the chain specification. 27 | pub fn new(id: Id, chain: impl Into) -> Self { 28 | Self(Rollup::new("pop", id, chain)) 29 | } 30 | } 31 | 32 | impl SourceT for Pop { 33 | type Error = Error; 34 | /// Defines the source of a binary. 35 | fn source(&self) -> Result { 36 | // Source from GitHub release asset 37 | let binary = self.binary(); 38 | Ok(Source::GitHub(ReleaseArchive { 39 | owner: "r0gue-io".into(), 40 | repository: "pop-node".into(), 41 | tag: None, 42 | tag_pattern: Some("node-{version}".into()), 43 | prerelease: false, 44 | version_comparator: sort_by_latest_semantic_version, 45 | fallback: "v0.3.0".into(), 46 | archive: format!("{binary}-{}.tar.gz", target()?), 47 | contents: vec![ArchiveFileSpec::new(binary.into(), None, true)], 48 | latest: None, 49 | })) 50 | } 51 | } 52 | 53 | impl Binary for Pop { 54 | fn binary(&self) -> &'static str { 55 | "pop-node" 56 | } 57 | } 58 | 59 | impl Requires for Pop { 60 | /// Defines the requirements of a rollup, namely which other chains it depends on and any 61 | /// corresponding overrides to genesis state. 62 | fn requires(&self) -> Option> { 63 | let id = self.id(); 64 | let amount: u128 = 1_200_000_000_000_000_000; 65 | 66 | Some(HashMap::from([( 67 | RollupTypeId::of::(), 68 | Box::new(move |genesis_overrides: &mut Map| { 69 | let sovereign_account = accounts::sibl(id).to_ss58check(); 70 | let endowment = json!([sovereign_account, amount]); 71 | // Add sovereign account endowment 72 | genesis_overrides 73 | .entry("balances") 74 | .and_modify(|balances| { 75 | let balances = 76 | balances.as_object_mut().expect("expected balances as object"); 77 | match balances.get_mut("balances") { 78 | None => { 79 | balances.insert("balances".to_string(), json!([endowment])); 80 | }, 81 | Some(balances) => { 82 | let balances = 83 | balances.as_array_mut().expect("expected balances as array"); 84 | balances.push(endowment.clone()); 85 | }, 86 | } 87 | }) 88 | .or_insert(json!({"balances": [endowment]})); 89 | }) as Override, 90 | )])) 91 | } 92 | } 93 | 94 | impl Args for Pop { 95 | fn args(&self) -> Option> { 96 | Some(vec![ 97 | "-lpop-api::extension=debug", 98 | "-lruntime::contracts=trace", 99 | "-lruntime::revive=trace", 100 | "-lruntime::revive::strace=trace", 101 | "-lxcm=trace", 102 | "--enable-offchain-indexing=true", 103 | ]) 104 | } 105 | } 106 | 107 | impl GenesisOverrides for Pop {} 108 | 109 | impl_rollup!(Pop); 110 | 111 | #[cfg(test)] 112 | mod tests { 113 | use super::*; 114 | use pop_common::SortedSlice; 115 | use std::ptr::fn_addr_eq; 116 | 117 | #[test] 118 | fn source_works() { 119 | let pop = Pop::new(3395, "pop"); 120 | assert!(matches!( 121 | pop.source().unwrap(), 122 | Source::GitHub(ReleaseArchive { owner, repository, tag, tag_pattern, prerelease, version_comparator, fallback, archive, contents, latest }) 123 | if owner == "r0gue-io" && 124 | repository == "pop-node" && 125 | tag == None && 126 | tag_pattern == Some("node-{version}".into()) && 127 | !prerelease && 128 | fn_addr_eq(version_comparator, sort_by_latest_semantic_version as for<'a> fn(&'a mut [String]) -> SortedSlice<'a, String>) && 129 | fallback == "v0.3.0" && 130 | archive == format!("pop-node-{}.tar.gz", target().unwrap()) && 131 | contents == vec![ArchiveFileSpec::new("pop-node".into(), None, true)] && 132 | latest == None 133 | )); 134 | } 135 | 136 | #[test] 137 | fn binary_works() { 138 | let pop = Pop::new(3395, "pop"); 139 | assert_eq!(pop.binary(), "pop-node"); 140 | } 141 | 142 | #[test] 143 | fn requires_asset_hub() { 144 | let pop = Pop::new(3395, "pop"); 145 | let mut requires = pop.requires().unwrap(); 146 | let r#override = requires.get_mut(&RollupTypeId::of::()).unwrap(); 147 | let expected = json!({ 148 | "balances": { 149 | "balances": [["5Eg2fnsomjubNiqxnqSSeVwcmQYQzsHdyr79YhcJDKRYfPCL", 1200000000000000000u64]] 150 | }}); 151 | // Empty 152 | let mut overrides = Map::new(); 153 | r#override(&mut overrides); 154 | assert_eq!(Value::Object(overrides), expected); 155 | // Inserts 156 | let mut overrides = Map::new(); 157 | overrides.insert("balances".to_string(), json!({})); 158 | r#override(&mut overrides); 159 | assert_eq!(Value::Object(overrides), expected); 160 | // Updates 161 | let mut overrides = Map::new(); 162 | overrides.insert("balances".to_string(), json!({ "balances": []})); 163 | r#override(&mut overrides); 164 | assert_eq!(Value::Object(overrides), expected); 165 | } 166 | 167 | #[test] 168 | fn args_works() { 169 | let pop = Pop::new(3395, "pop"); 170 | assert_eq!( 171 | pop.args().unwrap(), 172 | vec![ 173 | "-lpop-api::extension=debug", 174 | "-lruntime::contracts=trace", 175 | "-lruntime::revive=trace", 176 | "-lruntime::revive::strace=trace", 177 | "-lxcm=trace", 178 | "--enable-offchain-indexing=true", 179 | ] 180 | ); 181 | } 182 | } 183 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/relay.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use crate::{call, DynamicPayload, Error}; 4 | use scale::{Decode, Encode}; 5 | use sp_core::twox_128; 6 | use subxt::{ 7 | config::BlockHash, 8 | dynamic::{self, Value}, 9 | events::StaticEvent, 10 | ext::{scale_decode::DecodeAsType, scale_encode::EncodeAsType}, 11 | OnlineClient, PolkadotConfig, 12 | }; 13 | 14 | /// Clears the DMPQ state for the given parachain IDs. 15 | /// 16 | /// # Arguments 17 | /// * `client` - Client for the network which state is to be modified. 18 | /// * `para_ids` - List of ids to build the keys that will be mutated. 19 | pub async fn clear_dmpq( 20 | client: OnlineClient, 21 | para_ids: &[u32], 22 | ) -> Result { 23 | // Wait for blocks to be produced. 24 | let mut sub = client 25 | .blocks() 26 | .subscribe_finalized() 27 | .await 28 | .map_err(|e| Error::SubXtError(e.into()))?; 29 | for _ in 0..2 { 30 | sub.next().await; 31 | } 32 | 33 | // Generate storage keys to be removed 34 | let clear_dmq_keys = generate_storage_keys(para_ids); 35 | 36 | // Submit calls to remove specified keys 37 | let kill_storage = construct_kill_storage_call(clear_dmq_keys); 38 | let sudo = subxt_signer::sr25519::dev::alice(); 39 | let sudo_call = call::construct_sudo_extrinsic(kill_storage); 40 | client 41 | .tx() 42 | .sign_and_submit_default(&sudo_call, &sudo) 43 | .await 44 | .map_err(|e| Error::SubXtError(e.into())) 45 | } 46 | 47 | fn construct_kill_storage_call(keys: Vec>) -> DynamicPayload { 48 | dynamic::tx( 49 | "System", 50 | "kill_storage", 51 | vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], 52 | ) 53 | } 54 | 55 | fn generate_storage_keys(para_ids: &[u32]) -> Vec> { 56 | let dmp = twox_128("Dmp".as_bytes()); 57 | let dmp_queue_heads = twox_128("DownwardMessageQueueHeads".as_bytes()); 58 | let dmp_queues = twox_128("DownwardMessageQueues".as_bytes()); 59 | let mut clear_dmq_keys = Vec::>::new(); 60 | for id in para_ids { 61 | let id = id.to_le_bytes(); 62 | // DMP Queue Head 63 | let mut key = dmp.to_vec(); 64 | key.extend(&dmp_queue_heads); 65 | key.extend(sp_core::twox_64(&id)); 66 | key.extend(id); 67 | clear_dmq_keys.push(key); 68 | // DMP Queue 69 | let mut key = dmp.to_vec(); 70 | key.extend(&dmp_queues); 71 | key.extend(sp_core::twox_64(&id)); 72 | key.extend(id); 73 | clear_dmq_keys.push(key); 74 | } 75 | clear_dmq_keys 76 | } 77 | 78 | /// A supported relay chain. 79 | #[derive(Debug, PartialEq)] 80 | pub enum RelayChain { 81 | /// Paseo. 82 | PaseoLocal, 83 | /// Westend. 84 | WestendLocal, 85 | } 86 | 87 | impl RelayChain { 88 | /// Attempts to convert a chain identifier into a supported `RelayChain` variant. 89 | /// 90 | /// # Arguments 91 | /// * `id` - The relay chain identifier. 92 | pub fn from(id: &str) -> Option { 93 | match id { 94 | "paseo-local" => Some(RelayChain::PaseoLocal), 95 | "westend-local" => Some(RelayChain::WestendLocal), 96 | _ => None, 97 | } 98 | } 99 | } 100 | 101 | /// A event emitted when an id has been registered. 102 | #[derive(Debug, Encode, Decode, DecodeAsType, EncodeAsType)] 103 | #[decode_as_type(crate_path = "subxt::ext::scale_decode")] 104 | #[encode_as_type(crate_path = "subxt::ext::scale_encode")] 105 | pub struct Reserved { 106 | /// The id that has been reserved. 107 | pub para_id: u32, 108 | } 109 | impl StaticEvent for Reserved { 110 | const PALLET: &'static str = "Registrar"; 111 | const EVENT: &'static str = "Reserved"; 112 | } 113 | 114 | #[cfg(test)] 115 | mod tests { 116 | use super::*; 117 | use sp_core::twox_64; 118 | use RelayChain::*; 119 | 120 | #[test] 121 | fn construct_kill_storage_call_works() { 122 | let keys = vec!["key".as_bytes().to_vec()]; 123 | assert_eq!( 124 | construct_kill_storage_call(keys.clone()), 125 | dynamic::tx( 126 | "System", 127 | "kill_storage", 128 | vec![Value::unnamed_composite(keys.into_iter().map(Value::from_bytes))], 129 | ) 130 | ) 131 | } 132 | 133 | #[test] 134 | fn generate_storage_keys_works() { 135 | let para_ids = vec![1_000, 4_385]; 136 | let dmp = twox_128("Dmp".as_bytes()); 137 | let dmp_queue_heads = [dmp, twox_128("DownwardMessageQueueHeads".as_bytes())].concat(); 138 | let dmp_queues = [dmp, twox_128("DownwardMessageQueues".as_bytes())].concat(); 139 | 140 | assert_eq!( 141 | generate_storage_keys(¶_ids), 142 | para_ids 143 | .iter() 144 | .flat_map(|id| { 145 | let id = id.to_le_bytes().to_vec(); 146 | [ 147 | // DMP Queue Head 148 | [dmp_queue_heads.clone(), twox_64(&id).to_vec(), id.clone()].concat(), 149 | // DMP Queue 150 | [dmp_queues.clone(), twox_64(&id).to_vec(), id].concat(), 151 | ] 152 | }) 153 | .collect::>() 154 | ) 155 | } 156 | 157 | #[test] 158 | fn supported_relay_chains() { 159 | for (s, e) in [ 160 | // Only chains with sudo supported 161 | ("paseo-local", Some(PaseoLocal)), 162 | ("westend-local", Some(WestendLocal)), 163 | ("kusama-local", None), 164 | ("polkadot-local", None), 165 | ] { 166 | assert_eq!(RelayChain::from(s), e) 167 | } 168 | } 169 | } 170 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/traits.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use serde_json::{Map, Value}; 4 | 5 | /// A rollup identifier. 6 | pub type Id = u32; 7 | /// A function for providing genesis overrides. 8 | pub type Override = Box)>; 9 | /// A communication endpoint. 10 | pub type Port = u16; 11 | 12 | /// The arguments used when launching a node. 13 | pub trait Args { 14 | /// The default arguments to be used when launching a node. 15 | fn args(&self) -> Option>; 16 | } 17 | 18 | /// The binary used to launch a node. 19 | pub trait Binary { 20 | /// The name of the binary. 21 | fn binary(&self) -> &'static str; 22 | } 23 | 24 | /// A specification of a chain, providing the genesis configurations, boot nodes, and other 25 | /// parameters required to launch the chain. 26 | pub trait ChainSpec { 27 | /// The identifier of the chain, as used by the chain specification. 28 | fn chain(&self) -> &str; 29 | } 30 | 31 | /// Any overrides to genesis state. 32 | pub trait GenesisOverrides { 33 | /// Any overrides to genesis state. 34 | fn genesis_overrides(&self) -> Option { 35 | None 36 | } 37 | } 38 | 39 | /// A node. 40 | pub trait Node { 41 | /// The port to be used. 42 | fn port(&self) -> Option<&Port>; 43 | 44 | /// Set the port to be used. 45 | /// 46 | /// # Arguments 47 | /// * `port` - The port to be used. 48 | fn set_port(&mut self, port: Port); 49 | } 50 | 51 | /// An application-specific blockchain, validated by the validators of the relay chain. 52 | pub trait Rollup { 53 | /// The rollup identifier. 54 | fn id(&self) -> Id; 55 | 56 | /// The name of the chain. 57 | fn name(&self) -> &str; 58 | 59 | /// Set the rollup identifier. 60 | /// 61 | /// # Arguments 62 | /// * `id` - The rollup identifier. 63 | fn set_id(&mut self, id: Id); 64 | } 65 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/try_runtime/binary.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use pop_common::{ 4 | git::GitHub, 5 | polkadot_sdk::sort_by_latest_semantic_version, 6 | sourcing::{ 7 | filters::prefix, 8 | traits::{ 9 | enums::{Source as _, *}, 10 | Source as SourceT, 11 | }, 12 | ArchiveFileSpec, Binary, 13 | GitHub::*, 14 | Source, 15 | }, 16 | target, Error, 17 | }; 18 | use std::path::PathBuf; 19 | use strum_macros::EnumProperty; 20 | 21 | #[derive(Debug, EnumProperty, PartialEq)] 22 | pub(super) enum TryRuntimeCli { 23 | #[strum(props( 24 | Repository = "https://github.com/r0gue-io/try-runtime-cli", 25 | Binary = "try-runtime-cli", 26 | Fallback = "v0.8.0" 27 | ))] 28 | TryRuntime, 29 | } 30 | 31 | impl SourceT for TryRuntimeCli { 32 | type Error = Error; 33 | /// Defines the source of the binary required for testing runtime upgrades. 34 | fn source(&self) -> Result { 35 | // Source from GitHub release asset 36 | let repo = GitHub::parse(self.repository())?; 37 | let binary = self.binary(); 38 | Ok(Source::GitHub(ReleaseArchive { 39 | owner: repo.org, 40 | repository: repo.name, 41 | tag: None, 42 | tag_pattern: self.tag_pattern().map(|t| t.into()), 43 | prerelease: false, 44 | version_comparator: sort_by_latest_semantic_version, 45 | fallback: self.fallback().into(), 46 | archive: format!("{binary}-{}.tar.gz", target()?), 47 | contents: vec![ArchiveFileSpec::new(binary.into(), Some(binary.into()), true)], 48 | latest: None, 49 | })) 50 | } 51 | } 52 | 53 | /// Generate the source of the `try-runtime` binary on the remote repository. 54 | /// 55 | /// # Arguments 56 | /// * `cache` - The path to the directory where the binary should be cached. 57 | /// * `version` - An optional version string. If `None`, the latest available version is used. 58 | pub async fn try_runtime_generator(cache: PathBuf, version: Option<&str>) -> Result { 59 | let cli = TryRuntimeCli::TryRuntime; 60 | let name = cli.binary().to_string(); 61 | let source = cli 62 | .source()? 63 | .resolve(&name, version, cache.as_path(), |f| prefix(f, &name)) 64 | .await 65 | .into(); 66 | let binary = Binary::Source { name, source, cache: cache.to_path_buf() }; 67 | Ok(binary) 68 | } 69 | 70 | #[cfg(test)] 71 | mod tests { 72 | use super::*; 73 | use tempfile::tempdir; 74 | 75 | #[tokio::test] 76 | async fn try_runtime_generator_works() -> Result<(), Error> { 77 | let temp_dir = tempdir()?.into_path(); 78 | let version = "v0.8.0"; 79 | let binary = try_runtime_generator(temp_dir.clone(), None).await?; 80 | assert!(matches!(binary, Binary::Source { name: _, source, cache } 81 | if source == Source::GitHub(ReleaseArchive { 82 | owner: "r0gue-io".to_string(), 83 | repository: "try-runtime-cli".to_string(), 84 | tag: Some(version.to_string()), 85 | tag_pattern: None, 86 | prerelease: false, 87 | version_comparator: sort_by_latest_semantic_version, 88 | fallback: version.into(), 89 | archive: format!("try-runtime-cli-{}.tar.gz", target()?), 90 | contents: ["try-runtime-cli"].map(|b| ArchiveFileSpec::new(b.into(), Some(b.into()), true)).to_vec(), 91 | latest: binary.latest().map(|l| l.to_string()), 92 | }).into() && 93 | cache == temp_dir.as_path() 94 | )); 95 | Ok(()) 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/try_runtime/parse.rs: -------------------------------------------------------------------------------- 1 | // This file is part of try-runtime-cli. 2 | 3 | // Copyright (C) Parity Technologies (UK) Ltd. 4 | // SPDX-License-Identifier: Apache-2.0 5 | 6 | // Licensed under the Apache License, Version 2.0 (the "License"); 7 | // you may not use this file except in compliance with the License. 8 | // You may obtain a copy of the License at 9 | // 10 | // http://www.apache.org/licenses/LICENSE-2.0 11 | // 12 | // Unless required by applicable law or agreed to in writing, software 13 | // distributed under the License is distributed on an "AS IS" BASIS, 14 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | // See the License for the specific language governing permissions and 16 | // limitations under the License. 17 | 18 | use sp_version::StateVersion; 19 | 20 | use crate::Error; 21 | 22 | /// Parse a block hash from a string. 23 | pub fn hash(block_hash: &str) -> Result { 24 | let (block_hash, offset) = if let Some(block_hash) = block_hash.strip_prefix("0x") { 25 | (block_hash, 2) 26 | } else { 27 | (block_hash, 0) 28 | }; 29 | 30 | if let Some(pos) = block_hash.chars().position(|c| !c.is_ascii_hexdigit()) { 31 | Err(Error::ParamParsingError(format!( 32 | "Expected block hash, found illegal hex character at position: {}", 33 | offset + pos, 34 | ))) 35 | } else { 36 | Ok(block_hash.into()) 37 | } 38 | } 39 | 40 | /// Parse a URL from a string. 41 | pub fn url(s: &str) -> Result { 42 | if s.starts_with("ws://") || s.starts_with("wss://") { 43 | Ok(s.to_string()) 44 | } else { 45 | Err(Error::ParamParsingError( 46 | "not a valid WS(S) url: must start with 'ws://' or 'wss://'".to_string(), 47 | )) 48 | } 49 | } 50 | 51 | /// Parse a state version from a string. 52 | pub fn state_version(s: &str) -> Result { 53 | s.parse::() 54 | .map_err(|_| ()) 55 | .and_then(StateVersion::try_from) 56 | .map_err(|_| Error::ParamParsingError("Invalid state version.".to_string())) 57 | } 58 | 59 | #[cfg(test)] 60 | mod tests { 61 | use super::*; 62 | 63 | #[test] 64 | fn parse_hash_works() { 65 | assert!(hash("0x1234567890abcdef").is_ok()); 66 | assert!(hash("1234567890abcdef").is_ok()); 67 | assert!(hash("0x1234567890abcdefg").is_err()); 68 | assert!(hash("1234567890abcdefg").is_err()); 69 | } 70 | 71 | #[test] 72 | fn parse_url_works() { 73 | assert!(url("ws://localhost:9944").is_ok()); 74 | assert!(url("wss://localhost:9944").is_ok()); 75 | assert!(url("http://localhost:9944").is_err()); 76 | assert!(url("https://localhost:9944").is_err()); 77 | } 78 | 79 | #[test] 80 | fn parse_state_version_works() { 81 | assert!(state_version("0").is_ok()); 82 | assert!(state_version("1").is_ok()); 83 | assert!(state_version("100").is_err()); 84 | assert!(state_version("200").is_err()); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/try_runtime/shared_parameters.rs: -------------------------------------------------------------------------------- 1 | // This file is part of try-runtime-cli. 2 | 3 | // Copyright (C) Parity Technologies (UK) Ltd. 4 | // SPDX-License-Identifier: Apache-2.0 5 | 6 | // Licensed under the Apache License, Version 2.0 (the "License"); 7 | // you may not use this file except in compliance with the License. 8 | // You may obtain a copy of the License at 9 | // 10 | // http://www.apache.org/licenses/LICENSE-2.0 11 | // 12 | // Unless required by applicable law or agreed to in writing, software 13 | // distributed under the License is distributed on an "AS IS" BASIS, 14 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 | // See the License for the specific language governing permissions and 16 | // limitations under the License. 17 | 18 | use super::parse::state_version; 19 | use sc_cli::{ 20 | WasmExecutionMethod, WasmtimeInstantiationStrategy, DEFAULT_WASMTIME_INSTANTIATION_STRATEGY, 21 | DEFAULT_WASM_EXECUTION_METHOD, 22 | }; 23 | use sp_runtime::StateVersion; 24 | use std::{path::PathBuf, str::FromStr}; 25 | 26 | /// Shared parameters derived from the fields of struct [SharedParams]. 27 | const SHARED_PARAMS: [&str; 7] = [ 28 | "--runtime", 29 | "--disable-spec-name-check", 30 | "--wasm-execution", 31 | "--wasm-instantiation-strategy", 32 | "--heap-pages", 33 | "--export-proof", 34 | "--overwrite-state-version", 35 | ]; 36 | 37 | /// Shared parameters of the `try-runtime` commands 38 | #[derive(Debug, Clone, clap::Parser)] 39 | #[group(skip)] 40 | pub struct SharedParams { 41 | /// The runtime to use. 42 | /// 43 | /// Must be a path to a wasm blob, compiled with `try-runtime` feature flag. 44 | /// 45 | /// Or, `existing`, indicating that you don't want to overwrite the runtime. This will use 46 | /// whatever comes from the remote node, or the snapshot file. This will most likely not work 47 | /// against a remote node, as no (sane) blockchain should compile its onchain wasm with 48 | /// `try-runtime` feature. 49 | #[arg(long, default_value = "existing")] 50 | pub runtime: Runtime, 51 | 52 | /// Whether to disable enforcing the new runtime `spec_name` matches the existing `spec_name`. 53 | #[clap(long, default_value = "false", default_missing_value = "true")] 54 | pub disable_spec_name_check: bool, 55 | 56 | /// Type of wasm execution used. 57 | #[arg( 58 | long = "wasm-execution", 59 | value_name = "METHOD", 60 | value_enum, 61 | ignore_case = true, 62 | default_value_t = DEFAULT_WASM_EXECUTION_METHOD, 63 | )] 64 | pub wasm_method: WasmExecutionMethod, 65 | 66 | /// The WASM instantiation method to use. 67 | /// 68 | /// Only has an effect when `wasm-execution` is set to `compiled`. 69 | #[arg( 70 | long = "wasm-instantiation-strategy", 71 | value_name = "STRATEGY", 72 | default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY, 73 | value_enum, 74 | )] 75 | pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy, 76 | 77 | /// The number of 64KB pages to allocate for Wasm execution. Defaults to 78 | /// [`sc_service::Configuration.default_heap_pages`]. 79 | #[arg(long)] 80 | pub heap_pages: Option, 81 | 82 | /// Path to a file to export the storage proof into (as a JSON). 83 | /// If several blocks are executed, the path is interpreted as a folder 84 | /// where one file per block will be written (named `{block_number}-{block_hash}`). 85 | #[clap(long)] 86 | pub export_proof: Option, 87 | 88 | /// Overwrite the `state_version`. 89 | /// 90 | /// Otherwise `remote-externalities` will automatically set the correct state version. 91 | #[arg(long, value_parser = state_version)] 92 | pub overwrite_state_version: Option, 93 | } 94 | 95 | impl Default for SharedParams { 96 | fn default() -> Self { 97 | SharedParams { 98 | runtime: Runtime::Existing, 99 | disable_spec_name_check: false, 100 | wasm_method: DEFAULT_WASM_EXECUTION_METHOD, 101 | wasmtime_instantiation_strategy: DEFAULT_WASMTIME_INSTANTIATION_STRATEGY, 102 | heap_pages: None, 103 | export_proof: None, 104 | overwrite_state_version: None, 105 | } 106 | } 107 | } 108 | 109 | impl SharedParams { 110 | /// Check if the given argument is a shared parameter. 111 | pub fn has_argument(arg: &str) -> bool { 112 | SHARED_PARAMS.iter().any(|a| arg.starts_with(a)) 113 | } 114 | } 115 | 116 | /// Source of the runtime. 117 | #[derive(Debug, Clone)] 118 | pub enum Runtime { 119 | /// Use the given path to the wasm binary file. 120 | /// 121 | /// It must have been compiled with `try-runtime`. 122 | Path(PathBuf), 123 | 124 | /// Use the code of the remote node, or the snapshot. 125 | /// 126 | /// In almost all cases, this is not what you want, because the code in the remote node does 127 | /// not have any of the try-runtime custom runtime APIs. 128 | Existing, 129 | } 130 | 131 | impl FromStr for Runtime { 132 | type Err = String; 133 | 134 | fn from_str(s: &str) -> Result { 135 | Ok(match s.to_lowercase().as_ref() { 136 | "existing" => Runtime::Existing, 137 | x => Runtime::Path(x.into()), 138 | }) 139 | } 140 | } 141 | 142 | #[cfg(test)] 143 | mod tests { 144 | use super::*; 145 | 146 | #[test] 147 | fn is_shared_params_works() { 148 | assert!(SHARED_PARAMS.into_iter().all(SharedParams::has_argument)); 149 | } 150 | } 151 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/try_runtime/state.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use std::path::PathBuf; 4 | use strum::{Display, EnumDiscriminants}; 5 | use strum_macros::{AsRefStr, EnumMessage, EnumString, VariantArray}; 6 | 7 | /// The runtime *state*. 8 | #[derive(Clone, Debug, clap::Subcommand, EnumDiscriminants)] 9 | #[strum_discriminants(derive(AsRefStr, EnumString, EnumMessage, VariantArray, Display))] 10 | #[strum_discriminants(name(StateCommand))] 11 | pub enum State { 12 | /// A live chain. 13 | #[strum_discriminants(strum( 14 | serialize = "live", 15 | message = "Live", 16 | detailed_message = "Run the migrations on top of live state.", 17 | ))] 18 | Live(LiveState), 19 | 20 | /// A state snapshot. 21 | #[strum_discriminants(strum( 22 | serialize = "snap", 23 | message = "Snapshot", 24 | detailed_message = "Run the migrations on top of a chain snapshot." 25 | ))] 26 | Snap { 27 | /// Path to the snapshot file. 28 | #[clap(short = 'p', long = "path", alias = "snapshot-path")] 29 | path: Option, 30 | }, 31 | } 32 | 33 | /// A `Live` variant for [`State`] 34 | #[derive(Debug, Default, Clone, clap::Args)] 35 | pub struct LiveState { 36 | /// The url to connect to. 37 | #[arg( 38 | short, 39 | long, 40 | value_parser = super::parse::url, 41 | )] 42 | pub uri: Option, 43 | 44 | /// The block hash at which to fetch the state. 45 | /// 46 | /// If not provided the latest finalised head is used. 47 | #[arg( 48 | short, 49 | long, 50 | value_parser = super::parse::hash, 51 | )] 52 | pub at: Option, 53 | 54 | /// A pallet to scrape. Can be provided multiple times. If empty, entire chain state will 55 | /// be scraped. 56 | /// 57 | /// This is equivalent to passing `xx_hash_64(pallet)` to `--hashed_prefixes`. 58 | #[arg(short, long, num_args = 1..)] 59 | pub pallet: Vec, 60 | 61 | /// Storage entry key prefixes to scrape and inject into the test externalities. Pass as 0x 62 | /// prefixed hex strings. By default, all keys are scraped and included. 63 | #[arg(long = "prefix", value_parser = super::parse::hash, num_args = 1..)] 64 | pub hashed_prefixes: Vec, 65 | 66 | /// Fetch the child-keys. 67 | /// 68 | /// Default is `false`, if `--pallets` are specified, `true` otherwise. In other 69 | /// words, if you scrape the whole state the child tree data is included out of the box. 70 | /// Otherwise, it must be enabled explicitly using this flag. 71 | #[arg(long)] 72 | pub child_tree: bool, 73 | } 74 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/utils/helpers.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use crate::errors::Error; 4 | use std::{ 5 | fs::{self, OpenOptions}, 6 | io::{self, stdin, stdout, Write}, 7 | path::Path, 8 | }; 9 | 10 | pub(crate) fn sanitize(target: &Path) -> Result<(), Error> { 11 | if target.exists() { 12 | print!("\"{}\" directory exists. Do you want to clean it? [y/n]: ", target.display()); 13 | stdout().flush()?; 14 | 15 | let mut input = String::new(); 16 | stdin().read_line(&mut input)?; 17 | 18 | if input.trim().to_lowercase() == "y" { 19 | fs::remove_dir_all(target).map_err(|_| Error::Aborted)?; 20 | } else { 21 | return Err(Error::Aborted); 22 | } 23 | } 24 | Ok(()) 25 | } 26 | 27 | /// Check if the initial endowment input by the user is a valid balance. 28 | /// 29 | /// # Arguments 30 | /// 31 | /// * `initial_endowment` - initial endowment amount to be checked for validity. 32 | pub fn is_initial_endowment_valid(initial_endowment: &str) -> bool { 33 | initial_endowment.parse::().is_ok() || 34 | is_valid_bitwise_left_shift(initial_endowment).is_ok() 35 | } 36 | 37 | // Auxiliary method to check if the endowment input with a shift left (1u64 << 60) format is valid. 38 | // Parse the self << rhs format and check the shift left operation is valid. 39 | fn is_valid_bitwise_left_shift(initial_endowment: &str) -> Result { 40 | let v: Vec<&str> = initial_endowment.split(" << ").collect(); 41 | if v.len() < 2 { 42 | return Err(Error::EndowmentError); 43 | } 44 | let left = v[0] 45 | .split('u') // parse 1u64 characters 46 | .take(1) 47 | .collect::() 48 | .parse::() 49 | .map_err(|_e| Error::EndowmentError)?; 50 | let right = v[1] 51 | .chars() 52 | .filter(|c| c.is_numeric()) // parse 1u64 characters 53 | .collect::() 54 | .parse::() 55 | .map_err(|_e| Error::EndowmentError)?; 56 | left.checked_shl(right).ok_or(Error::EndowmentError) 57 | } 58 | 59 | pub(crate) fn write_to_file(path: &Path, contents: &str) -> Result<(), Error> { 60 | let mut file = OpenOptions::new() 61 | .write(true) 62 | .truncate(true) 63 | .create(true) 64 | .open(path) 65 | .map_err(Error::RustfmtError)?; 66 | 67 | file.write_all(contents.as_bytes()).map_err(Error::RustfmtError)?; 68 | 69 | if path.extension().is_some_and(|ext| ext == "rs") { 70 | let output = std::process::Command::new("rustfmt") 71 | .arg(path.to_str().unwrap()) 72 | .output() 73 | .map_err(Error::RustfmtError)?; 74 | 75 | if !output.status.success() { 76 | return Err(Error::RustfmtError(io::Error::new( 77 | io::ErrorKind::Other, 78 | "rustfmt exited with non-zero status code", 79 | ))); 80 | } 81 | } 82 | 83 | Ok(()) 84 | } 85 | 86 | #[cfg(test)] 87 | mod tests { 88 | use super::*; 89 | use crate::{generator::parachain::ChainSpec, Parachain}; 90 | use askama::Template; 91 | use tempfile::tempdir; 92 | 93 | #[test] 94 | fn test_write_to_file() -> Result<(), Box> { 95 | let temp_dir = tempdir()?; 96 | let chainspec = ChainSpec { 97 | token_symbol: "DOT".to_string(), 98 | decimals: 6, 99 | initial_endowment: "1000000".to_string(), 100 | based_on: Parachain::Standard.to_string(), 101 | }; 102 | let file_path = temp_dir.path().join("file.rs"); 103 | let _ = fs::write(&file_path, ""); 104 | write_to_file(&file_path, chainspec.render().expect("infallible").as_ref())?; 105 | let generated_file_content = 106 | fs::read_to_string(temp_dir.path().join("file.rs")).expect("Failed to read file"); 107 | assert!(generated_file_content 108 | .contains("properties.insert(\"tokenSymbol\".into(), \"DOT\".into());")); 109 | assert!(generated_file_content 110 | .contains("properties.insert(\"tokenDecimals\".into(), 6.into());")); 111 | assert!(generated_file_content.contains("1000000")); 112 | assert!(generated_file_content.contains( 113 | "properties.insert(\"basedOn\".into(), \"r0gue-io/base-parachain\".into());" 114 | )); 115 | 116 | Ok(()) 117 | } 118 | 119 | #[test] 120 | fn test_is_initial_endowment_valid() { 121 | assert_eq!(is_initial_endowment_valid("100000"), true); 122 | assert_eq!(is_initial_endowment_valid("1u64 << 60"), true); 123 | assert_eq!(is_initial_endowment_valid("wrong"), false); 124 | assert_eq!(is_initial_endowment_valid(" "), false); 125 | } 126 | 127 | #[test] 128 | fn test_left_shift() { 129 | // Values from https://stackoverflow.com/questions/56392875/how-can-i-initialize-a-users-balance-in-a-substrate-blockchain 130 | assert_eq!(is_valid_bitwise_left_shift("1 << 60").unwrap(), 1152921504606846976); 131 | let result = is_valid_bitwise_left_shift("wrong"); 132 | assert!(result.is_err()); 133 | } 134 | } 135 | -------------------------------------------------------------------------------- /crates/pop-parachains/src/utils/mod.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | pub mod helpers; 4 | -------------------------------------------------------------------------------- /crates/pop-parachains/templates/base/network.templ: -------------------------------------------------------------------------------- 1 | [relaychain] 2 | chain = "paseo-local" 3 | 4 | [[relaychain.nodes]] 5 | name = "alice" 6 | validator = true 7 | 8 | [[relaychain.nodes]] 9 | name = "bob" 10 | validator = true 11 | 12 | [[parachains]] 13 | id = 2000 14 | default_command = "./target/release/^^node^^" 15 | 16 | [[parachains.collators]] 17 | name = "collator-01" -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/Cargo.templ: -------------------------------------------------------------------------------- 1 | {{- let using_currency = pallet_common_types|contains(TemplatePalletConfigCommonTypes::Currency) -}} 2 | [package] 3 | name = "pallet-^^name|lower^^" 4 | authors = ["^^authors^^"] 5 | description = "^^description^^" 6 | version = "0.1.0" 7 | license = "Unlicense" 8 | {{- if pallet_in_workspace }} 9 | edition.workspace = true 10 | repository.workspace = true 11 | {{- else }} 12 | edition = "2021" 13 | {{- endif }} 14 | 15 | [package.metadata.docs.rs] 16 | targets = ["x86_64-unknown-linux-gnu"] 17 | 18 | [dependencies] 19 | codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ 20 | "derive", 21 | ] } 22 | scale-info = { version = "2.11.1", default-features = false, features = [ 23 | "derive", 24 | ] } 25 | frame = { version = "0.3.0", package = "polkadot-sdk-frame", default-features = false, features = ["experimental", "runtime"] } 26 | 27 | {{ if using_currency }} 28 | [dev-dependencies] 29 | pallet-balances = { version = "35.0.0" } 30 | {{- endif }} 31 | 32 | [features] 33 | default = ["std"] 34 | std = [ 35 | "codec/std", 36 | "frame/std", 37 | "scale-info/std", 38 | ] 39 | runtime-benchmarks = ["frame/runtime-benchmarks"] 40 | try-runtime = ["frame/try-runtime"] 41 | -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/benchmarking.rs.templ: -------------------------------------------------------------------------------- 1 | use super::*; 2 | 3 | #[allow(unused)] 4 | use crate::{frame_system::RawOrigin, Pallet, mock::{new_test_ext, Test}}; 5 | use frame::deps::frame_benchmarking::v2::*; 6 | 7 | #[benchmarks] 8 | mod benchmarks { 9 | use super::*; 10 | 11 | #[benchmark] 12 | fn some_benchmark(){} 13 | 14 | impl_benchmark_test_suite!(Pallet, new_test_ext(), Test); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/config_preludes.rs.templ: -------------------------------------------------------------------------------- 1 | {{- let using_runtime_event = pallet_common_types|contains(TemplatePalletConfigCommonTypes::RuntimeEvent) -}} 2 | {{- let using_runtime_origin = pallet_common_types|contains(TemplatePalletConfigCommonTypes::RuntimeOrigin) -}} 3 | {{- let using_currency = pallet_common_types|contains(TemplatePalletConfigCommonTypes::Currency) -}} 4 | use super::*; 5 | use frame::runtime::prelude::derive_impl; 6 | 7 | /// Provides a viable default config that can be used with 8 | /// [`derive_impl`] to derive a testing pallet config 9 | /// based on this one. 10 | pub struct TestDefaultConfig; 11 | 12 | #[derive_impl(frame_system::config_preludes::TestDefaultConfig, no_aggregated_types)] 13 | impl frame::deps::frame_system::DefaultConfig for TestDefaultConfig {} 14 | 15 | #[register_default_impl(TestDefaultConfig)] 16 | impl DefaultConfig for TestDefaultConfig { 17 | {{- if using_runtime_event -}} 18 | #[inject_runtime_type] 19 | type RuntimeEvent = (); 20 | {{- endif -}} 21 | {{- if using_runtime_origin || pallet_custom_origin -}} 22 | #[inject_runtime_type] 23 | type RuntimeOrigin = (); 24 | {{- endif -}} 25 | {{- if using_currency -}} 26 | #[inject_runtime_type] 27 | type RuntimeHoldReason = (); 28 | #[inject_runtime_type] 29 | type RuntimeFreezeReason = (); 30 | {{- endif -}} 31 | } 32 | 33 | /// Default configurations of this pallet in a solochain environment. 34 | pub struct SolochainDefaultConfig; 35 | 36 | #[derive_impl(frame_system::config_preludes::SolochainDefaultConfig, no_aggregated_types)] 37 | impl frame::deps::frame_system::DefaultConfig for SolochainDefaultConfig {} 38 | 39 | #[register_default_impl(SolochainDefaultConfig)] 40 | impl DefaultConfig for SolochainDefaultConfig { 41 | {{- if using_runtime_event -}} 42 | #[inject_runtime_type] 43 | type RuntimeEvent = (); 44 | {{- endif -}} 45 | {{- if using_runtime_origin || pallet_custom_origin -}} 46 | #[inject_runtime_type] 47 | type RuntimeOrigin = (); 48 | {{- endif -}} 49 | {{- if using_currency -}} 50 | #[inject_runtime_type] 51 | type RuntimeHoldReason = (); 52 | #[inject_runtime_type] 53 | type RuntimeFreezeReason = (); 54 | {{- endif -}} 55 | } 56 | 57 | /// Default configurations of this pallet in a solochain environment. 58 | pub struct RelayChainDefaultConfig; 59 | 60 | #[derive_impl(frame_system::config_preludes::RelayChainDefaultConfig, no_aggregated_types)] 61 | impl frame::deps::frame_system::DefaultConfig for RelayChainDefaultConfig {} 62 | 63 | #[register_default_impl(RelayChainDefaultConfig)] 64 | impl DefaultConfig for RelayChainDefaultConfig { 65 | {{- if using_runtime_event -}} 66 | #[inject_runtime_type] 67 | type RuntimeEvent = (); 68 | {{- endif -}} 69 | {{- if using_runtime_origin || pallet_custom_origin -}} 70 | #[inject_runtime_type] 71 | type RuntimeOrigin = (); 72 | {{- endif -}} 73 | {{- if using_currency -}} 74 | #[inject_runtime_type] 75 | type RuntimeHoldReason = (); 76 | #[inject_runtime_type] 77 | type RuntimeFreezeReason = (); 78 | {{- endif -}} 79 | } 80 | 81 | /// Default configurations of this pallet in a solochain environment. 82 | pub struct ParaChainDefaultConfig; 83 | 84 | #[derive_impl(frame_system::config_preludes::ParaChainDefaultConfig, no_aggregated_types)] 85 | impl frame::deps::frame_system::DefaultConfig for ParaChainDefaultConfig {} 86 | 87 | #[register_default_impl(ParaChainDefaultConfig)] 88 | impl DefaultConfig for ParaChainDefaultConfig{ 89 | {{- if using_runtime_event -}} 90 | #[inject_runtime_type] 91 | type RuntimeEvent = (); 92 | {{- endif -}} 93 | {{- if using_runtime_origin || pallet_custom_origin -}} 94 | #[inject_runtime_type] 95 | type RuntimeOrigin = (); 96 | {{- endif -}} 97 | {{- if using_currency -}} 98 | #[inject_runtime_type] 99 | type RuntimeHoldReason = (); 100 | #[inject_runtime_type] 101 | type RuntimeFreezeReason = (); 102 | {{- endif -}} 103 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/mock.rs.templ: -------------------------------------------------------------------------------- 1 | {{- let using_runtime_event = pallet_common_types|contains(TemplatePalletConfigCommonTypes::RuntimeEvent) -}} 2 | {{- let using_runtime_origin = pallet_common_types|contains(TemplatePalletConfigCommonTypes::RuntimeOrigin) -}} 3 | {{- let using_currency = pallet_common_types|contains(TemplatePalletConfigCommonTypes::Currency) -}} 4 | use crate::{self as pallet_^^name|lower^^, *}; 5 | 6 | pub use frame::{ 7 | deps::{frame_support::runtime, sp_io::TestExternalities}, 8 | runtime::prelude::*, 9 | testing_prelude::*, 10 | {{- if using_currency }} 11 | traits::fungible::Mutate 12 | {{- endif }} 13 | }; 14 | 15 | type Block = MockBlock; 16 | 17 | {{ if using_currency }} 18 | type Balance = u64; 19 | {{- endif }} 20 | 21 | #[runtime] 22 | mod runtime{ 23 | #[runtime::runtime] 24 | #[runtime::derive( 25 | RuntimeCall, 26 | RuntimeEvent, 27 | RuntimeError, 28 | RuntimeOrigin, 29 | RuntimeFreezeReason, 30 | RuntimeHoldReason, 31 | RuntimeSlashReason, 32 | RuntimeLockId, 33 | RuntimeTask 34 | )] 35 | pub struct Test; 36 | 37 | #[runtime::pallet_index(0)] 38 | pub type System = frame_system; 39 | 40 | {{ if using_currency }} 41 | #[runtime::pallet_index(1)] 42 | pub type Balances = pallet_balances; 43 | {{- endif }} 44 | 45 | #[runtime::pallet_index(2)] 46 | pub type ^^name|capitalize^^ = pallet_^^name|lower^^; 47 | } 48 | 49 | #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] 50 | impl frame_system::Config for Test { 51 | type Block = Block; 52 | {{- if using_currency -}} 53 | type AccountData = pallet_balances::AccountData; 54 | {{- endif -}} 55 | } 56 | 57 | {{ if using_currency -}} 58 | #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] 59 | impl pallet_balances::Config for Test { 60 | type AccountStore = System; 61 | } 62 | {{- endif }} 63 | 64 | {{- if pallet_default_config }} 65 | #[derive_impl(pallet_^^name|lower^^::config_preludes::TestDefaultConfig)] 66 | {{- endif }} 67 | impl pallet_^^name|lower^^::Config for Test { 68 | {{- if using_runtime_event && !pallet_default_config -}} 69 | type RuntimeEvent = RuntimeEvent; 70 | {{- endif -}} 71 | {{- if (using_runtime_origin || pallet_custom_origin) && !pallet_default_config -}} 72 | type RuntimeOrigin = RuntimeOrigin; 73 | {{- endif -}} 74 | {{- if using_currency -}} 75 | type Currency = Balances; 76 | {{- if !pallet_default_config }} 77 | type RuntimeHoldReason = RuntimeHoldReason; 78 | type RuntimeFreezeReason = RuntimeFreezeReason; 79 | {{- endif -}} 80 | {{- endif -}} 81 | } 82 | 83 | pub(crate) struct StateBuilder{ 84 | {{- if using_currency -}} 85 | balances: Vec<(::AccountId, Balance)> 86 | {{- endif -}} 87 | } 88 | 89 | impl Default for StateBuilder{ 90 | fn default() -> Self { 91 | Self { 92 | {{-if using_currency -}} 93 | balances: vec![] 94 | {{- endif -}} 95 | } 96 | } 97 | } 98 | 99 | impl StateBuilder { 100 | {{- if using_currency -}} 101 | /// This function helps to construct a initial state where some accounts have balances 102 | fn add_balance( 103 | mut self, 104 | who: ::AccountId, 105 | amount: Balance, 106 | ) -> Self { 107 | self.balances.push((who, amount)); 108 | self 109 | } 110 | {{- endif }} 111 | 112 | pub(crate) fn build_and_execute(self, test: impl FnOnce() -> ()) { 113 | let mut ext: TestExternalities = frame_system::GenesisConfig::::default() 114 | .build_storage() 115 | .unwrap() 116 | .into(); 117 | 118 | // Test setup 119 | ext.execute_with(|| { 120 | System::set_block_number(1); 121 | {{- if using_currency -}} 122 | self.balances.iter().for_each(|(who, amount)| { 123 | ::Currency::set_balance(who, *amount); 124 | }) 125 | {{- endif }} 126 | }); 127 | 128 | ext.execute_with(test); 129 | 130 | // Test assertions 131 | ext.execute_with(|| { 132 | 133 | }); 134 | } 135 | } 136 | 137 | pub fn new_test_ext() -> TestExternalities { 138 | frame_system::GenesisConfig::::default() 139 | .build_storage() 140 | .unwrap() 141 | .into() 142 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/pallet_logic.rs.templ: -------------------------------------------------------------------------------- 1 | // A mod containing the try_state logic. 2 | mod try_state; 3 | {{- if pallet_custom_origin }} 4 | // A mod containing logic to manage the pallet's custom origin 5 | mod origin; 6 | {{- endif -}} -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/pallet_logic/origin.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::*; 2 | 3 | impl Pallet { 4 | /// A helpful function your pallet may use to convert a external origin to the custom AllOrigins 5 | pub(crate) fn origin_to_all_origins(_origin: OriginFor) -> Result, DispatchError>{ 6 | Ok(>::from(>::AllOrigins)) 7 | } 8 | 9 | /// A helpful function your pallet may use to convert a external origin to the custom OnlyAuthenticatedAccounts 10 | pub(crate) fn origin_to_only_authenticated_accounts(origin: OriginFor) -> Result, DispatchError>{ 11 | Ok(>::from(>::OnlyAuthenticatedAccounts(ensure_signed(origin)?))) 12 | } 13 | } 14 | 15 | impl, OuterOrigin>> + From>> EnsureOrigin for Origin 16 | { 17 | type Success = CustomOriginSuccess; 18 | 19 | fn try_origin(outer_origin: OuterOrigin) -> Result{ 20 | outer_origin.into().and_then(|origin|match origin{ 21 | Origin::AllOrigins if >::exists() => Ok(Self::Success::Unit), 22 | Origin::OnlyAuthenticatedAccounts(account) if >::contains_key(&account) => Ok(Self::Success::AccountId(account)), 23 | other => Err(OuterOrigin::from(other)) 24 | }) 25 | } 26 | 27 | #[cfg(feature= "runtime-benchmarks")] 28 | fn try_successful_origin() -> Result{ 29 | Ok(OuterOrigin::from(>::AllOrigins)) 30 | } 31 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/pallet_logic/try_state.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::pallet::*; 2 | 3 | impl Pallet { 4 | #[cfg(feature = "try-runtime")] 5 | pub(crate) fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> { 6 | // TODO: Write here your try_state logic if needed 7 | Ok(()) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/tests.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::{*, mock::*}; 2 | 3 | // Some utils useful for testing 4 | mod utils; 5 | 6 | // You can split your tests in modules and add them here, or just write them down :) -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/tests/utils.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::tests::*; 2 | /// A function useful to advance a block :) If your pallet implements on_initialize, this is a good place to run it. 3 | pub fn next_block() { 4 | System::set_block_number(System::block_number() + 1); 5 | System::on_initialize(System::block_number()); 6 | // ^^name|capitalize^^::on_initialize(System::block_number()); 7 | #[cfg(feature = "try-runtime")] 8 | ^^name|capitalize^^::try_state(System::block_number()).expect("State corrupted"); 9 | } 10 | 11 | /// A function useful to run til the desired block. If your pallet implements on_finalize, this is a good place to run it. 12 | pub fn run_to_block(n: BlockNumberFor) { 13 | while System::block_number() < n { 14 | if System::block_number() > 1 { 15 | System::on_finalize(System::block_number()); 16 | // ^^name|capitalize^^::on_finalize(System::block_number()); 17 | } 18 | next_block(); 19 | } 20 | } 21 | 22 | /// Typically in tests, AccountId is just a number. With this macro you can give them a friendly ident 23 | /// # Example 24 | /// ```rust 25 | /// give_accounts_names!(alice, bob, charlie); 26 | /// assert_eq!(alice, 1); 27 | /// assert_eq!(bob, 2); 28 | /// assert_eq!(charlie, 3); 29 | /// ``` 30 | #[macro_export] 31 | macro_rules! give_accounts_names{ 32 | ($($account: ident),+) => { 33 | let mut counter: ::AccountId = 0; 34 | $( 35 | counter +=1; 36 | let $account = counter; 37 | )+ 38 | }; 39 | } 40 | 41 | /// This macro's useful to test that an unsigned origin cannot call an extrinsic requiring a signed origin 42 | #[macro_export] 43 | macro_rules! not_signed_call_triggers_bad_origin_test{ 44 | ($test_name: ident, $extrinsic: ident, $($arg: expr),*) =>{ 45 | #[test] 46 | fn $test_name(){ 47 | new_test_ext().execute_with(||{ 48 | assert_noop!(^^name|capitalize^^::$extrinsic(RuntimeOrigin::none(), $($arg),*), DispatchError::BadOrigin); 49 | }) 50 | } 51 | }; 52 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/advanced_mode/src/types.rs.templ: -------------------------------------------------------------------------------- 1 | {{- let using_runtime_origin = pallet_common_types|contains(TemplatePalletConfigCommonTypes::RuntimeOrigin) -}} 2 | {{- let using_currency = pallet_common_types|contains(TemplatePalletConfigCommonTypes::Currency) -}} 3 | use crate::*; 4 | 5 | {{ if using_runtime_origin || pallet_custom_origin }} 6 | /// An alias referencing the RuntimeOrigin config type. 7 | pub type RuntimeLocalOrigin = ::RuntimeOrigin; 8 | {{- endif }} 9 | 10 | {{ if using_currency }} 11 | /// An alias referencing the native currency's balance of an account. 12 | pub type BalanceOf = <::Currency as fungible::Inspect<::AccountId>>::Balance; 13 | {{- endif }} 14 | 15 | {{ if pallet_storage|contains(TemplatePalletStorageTypes::StorageMap) }} 16 | /// A fancy struct that can be used to store information together in storage. It's storing some bytes chosen and the Block number when it's registered SCALE compact encoded. This struct will be linked to a AccountId via MyStorageMap 17 | #[derive(TypeInfo, Encode, Decode, MaxEncodedLen, PartialEq, RuntimeDebugNoBound)] 18 | #[scale_info(skip_type_params(T))] 19 | pub struct AccountInfo { 20 | // Awesome bytes 21 | pub my_bytes: [u8;10], 22 | // The block where the account registered the phrase 23 | #[codec(compact)] 24 | pub block_joined: BlockNumberFor, 25 | } 26 | {{ endif }} 27 | 28 | {{ if pallet_custom_origin }} 29 | pub enum CustomOriginSuccess{ 30 | AccountId(T::AccountId), 31 | Unit 32 | } 33 | {{ endif }} 34 | -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/simple_mode/src/benchmarking.rs.templ: -------------------------------------------------------------------------------- 1 | #![cfg(feature = "runtime-benchmarks")] 2 | 3 | use super::*; 4 | use frame::deps::frame_benchmarking::v2::*; 5 | 6 | #[benchmarks] 7 | mod benchmarks { 8 | use super::*; 9 | #[cfg(test)] 10 | use crate::pallet::Pallet as Template; 11 | use frame_system::RawOrigin; 12 | 13 | #[benchmark] 14 | fn do_something() { 15 | let caller: T::AccountId = whitelisted_caller(); 16 | #[extrinsic_call] 17 | do_something(RawOrigin::Signed(caller), 100); 18 | 19 | assert_eq!(Something::::get().map(|v| v.block_number), Some(100u32.into())); 20 | } 21 | 22 | #[benchmark] 23 | fn cause_error() { 24 | let caller: T::AccountId = whitelisted_caller(); 25 | Something::::put(CompositeStruct { block_number: 100u32.into(), someone: caller.clone() }); 26 | #[extrinsic_call] 27 | cause_error(RawOrigin::Signed(caller)); 28 | 29 | assert_eq!(Something::::get().map(|v| v.block_number), Some(101u32.into())); 30 | } 31 | 32 | impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test); 33 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/simple_mode/src/mock.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::frame_system::{mocking::MockBlock, GenesisConfig}; 2 | use frame::{deps::frame_support::{runtime, derive_impl, weights::constants::RocksDbWeight}, runtime::prelude::*, testing_prelude::*}; 3 | 4 | // Configure a mock runtime to test the pallet. 5 | #[runtime] 6 | mod test_runtime { 7 | #[runtime::runtime] 8 | #[runtime::derive( 9 | RuntimeCall, 10 | RuntimeEvent, 11 | RuntimeError, 12 | RuntimeOrigin, 13 | RuntimeFreezeReason, 14 | RuntimeHoldReason, 15 | RuntimeSlashReason, 16 | RuntimeLockId, 17 | RuntimeTask 18 | )] 19 | pub struct Test; 20 | 21 | #[runtime::pallet_index(0)] 22 | pub type System = frame_system; 23 | #[runtime::pallet_index(1)] 24 | pub type ^^name|capitalize^^ = crate; 25 | } 26 | 27 | #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] 28 | impl frame_system::Config for Test { 29 | type Nonce = u64; 30 | type Block = MockBlock; 31 | type BlockHashCount = ConstU64<250>; 32 | type DbWeight = RocksDbWeight; 33 | } 34 | 35 | impl crate::Config for Test { 36 | type RuntimeEvent = RuntimeEvent; 37 | type WeightInfo = (); 38 | } 39 | 40 | // Build genesis storage according to the mock runtime. 41 | pub fn new_test_ext() -> sp_io::TestExternalities { 42 | GenesisConfig::::default().build_storage().unwrap().into() 43 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/simple_mode/src/tests.rs.templ: -------------------------------------------------------------------------------- 1 | use crate::{mock::*, *}; 2 | use frame::deps::frame_support::{assert_noop, assert_ok}; 3 | 4 | #[test] 5 | fn it_works_for_default_value() { 6 | new_test_ext().execute_with(|| { 7 | // Dispatch a signed extrinsic. 8 | assert_ok!(^^name|capitalize^^::do_something(RuntimeOrigin::signed(1), 42)); 9 | // Read pallet storage and assert an expected result. 10 | assert_eq!(Something::::get().map(|v| v.block_number), Some(42)); 11 | }); 12 | } 13 | 14 | #[test] 15 | fn correct_error_for_none_value() { 16 | new_test_ext().execute_with(|| { 17 | // Ensure the expected error is thrown when no value is present. 18 | assert_noop!( 19 | ^^name|capitalize^^::cause_error(RuntimeOrigin::signed(1)), 20 | Error::::NoneValue 21 | ); 22 | }); 23 | } -------------------------------------------------------------------------------- /crates/pop-parachains/templates/pallet/simple_mode/src/weights.rs.templ: -------------------------------------------------------------------------------- 1 | 2 | //! Autogenerated weights for pallet_template 3 | //! 4 | //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev 5 | //! DATE: 2023-04-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` 6 | //! WORST CASE MAP SIZE: `1000000` 7 | //! HOSTNAME: `_`, CPU: `` 8 | //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 9 | 10 | // Executed Command: 11 | // ../../target/release/node-template 12 | // benchmark 13 | // pallet 14 | // --chain 15 | // dev 16 | // --pallet 17 | // pallet_template 18 | // --extrinsic 19 | // * 20 | // --steps=50 21 | // --repeat=20 22 | // --wasm-execution=compiled 23 | // --output 24 | // pallets/template/src/weights.rs 25 | // --template 26 | // ../../.maintain/frame-weight-template.hbs 27 | 28 | #![cfg_attr(rustfmt, rustfmt_skip)] 29 | #![allow(unused_parens)] 30 | #![allow(unused_imports)] 31 | 32 | use frame::deps::{frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}, frame_system}; 33 | use core::marker::PhantomData; 34 | 35 | /// Weight functions needed for pallet_template. 36 | pub trait WeightInfo { 37 | fn do_something() -> Weight; 38 | fn cause_error() -> Weight; 39 | } 40 | 41 | /// Weights for pallet_template using the Substrate node and recommended hardware. 42 | pub struct SubstrateWeight(PhantomData); 43 | impl WeightInfo for SubstrateWeight { 44 | /// Storage: TemplateModule Something (r:0 w:1) 45 | /// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) 46 | fn do_something() -> Weight { 47 | // Proof Size summary in bytes: 48 | // Measured: `0` 49 | // Estimated: `0` 50 | // Minimum execution time: 8_000_000 picoseconds. 51 | Weight::from_parts(9_000_000, 0) 52 | .saturating_add(T::DbWeight::get().writes(1_u64)) 53 | } 54 | /// Storage: TemplateModule Something (r:1 w:1) 55 | /// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) 56 | fn cause_error() -> Weight { 57 | // Proof Size summary in bytes: 58 | // Measured: `32` 59 | // Estimated: `1489` 60 | // Minimum execution time: 6_000_000 picoseconds. 61 | Weight::from_parts(6_000_000, 1489) 62 | .saturating_add(T::DbWeight::get().reads(1_u64)) 63 | .saturating_add(T::DbWeight::get().writes(1_u64)) 64 | } 65 | } 66 | 67 | // For backwards compatibility and tests 68 | impl WeightInfo for () { 69 | /// Storage: TemplateModule Something (r:0 w:1) 70 | /// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) 71 | fn do_something() -> Weight { 72 | // Proof Size summary in bytes: 73 | // Measured: `0` 74 | // Estimated: `0` 75 | // Minimum execution time: 8_000_000 picoseconds. 76 | Weight::from_parts(9_000_000, 0) 77 | .saturating_add(RocksDbWeight::get().writes(1_u64)) 78 | } 79 | /// Storage: TemplateModule Something (r:1 w:1) 80 | /// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) 81 | fn cause_error() -> Weight { 82 | // Proof Size summary in bytes: 83 | // Measured: `32` 84 | // Estimated: `1489` 85 | // Minimum execution time: 6_000_000 picoseconds. 86 | Weight::from_parts(6_000_000, 1489) 87 | .saturating_add(RocksDbWeight::get().reads(1_u64)) 88 | .saturating_add(RocksDbWeight::get().writes(1_u64)) 89 | } 90 | } -------------------------------------------------------------------------------- /crates/pop-parachains/tests/parachain.rs: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0 2 | 3 | use anyhow::Result; 4 | use pop_parachains::up::Zombienet; 5 | use std::path::Path; 6 | 7 | const BINARY_VERSION: &str = "stable2412"; 8 | 9 | #[tokio::test] 10 | async fn launch_kusama() -> Result<()> { 11 | let temp_dir = tempfile::tempdir()?; 12 | let cache = temp_dir.path().to_path_buf(); 13 | 14 | let mut zombienet = Zombienet::new( 15 | &cache, 16 | Path::new("../../tests/networks/kusama.toml").try_into()?, 17 | Some(BINARY_VERSION), 18 | Some("v1.2.7"), 19 | None, 20 | None, 21 | None, 22 | ) 23 | .await?; 24 | 25 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 26 | binary.source(true, &(), true).await?; 27 | } 28 | 29 | zombienet.spawn().await?; 30 | Ok(()) 31 | } 32 | 33 | #[tokio::test] 34 | async fn launch_paseo() -> Result<()> { 35 | let temp_dir = tempfile::tempdir()?; 36 | let cache = temp_dir.path().to_path_buf(); 37 | 38 | let mut zombienet = Zombienet::new( 39 | &cache, 40 | Path::new("../../tests/networks/paseo.toml").try_into()?, 41 | Some(BINARY_VERSION), 42 | Some("v1.2.4"), 43 | None, 44 | None, 45 | None, 46 | ) 47 | .await?; 48 | 49 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 50 | binary.source(true, &(), true).await?; 51 | } 52 | 53 | zombienet.spawn().await?; 54 | Ok(()) 55 | } 56 | 57 | #[tokio::test] 58 | async fn launch_polkadot() -> Result<()> { 59 | let temp_dir = tempfile::tempdir()?; 60 | let cache = temp_dir.path().to_path_buf(); 61 | 62 | let mut zombienet = Zombienet::new( 63 | &cache, 64 | Path::new("../../tests/networks/polkadot.toml").try_into()?, 65 | Some(BINARY_VERSION), 66 | Some("v1.2.7"), 67 | None, 68 | None, 69 | None, 70 | ) 71 | .await?; 72 | 73 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 74 | binary.source(true, &(), true).await?; 75 | } 76 | 77 | zombienet.spawn().await?; 78 | Ok(()) 79 | } 80 | 81 | #[tokio::test] 82 | async fn launch_polkadot_and_system_parachain() -> Result<()> { 83 | let temp_dir = tempfile::tempdir()?; 84 | let cache = temp_dir.path().to_path_buf(); 85 | 86 | let mut zombienet = Zombienet::new( 87 | &cache, 88 | Path::new("../../tests/networks/polkadot+collectives.toml").try_into()?, 89 | Some(BINARY_VERSION), 90 | Some("v1.2.7"), 91 | Some(BINARY_VERSION), 92 | Some("v1.2.7"), 93 | None, 94 | ) 95 | .await?; 96 | 97 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 98 | binary.source(true, &(), true).await?; 99 | } 100 | 101 | zombienet.spawn().await?; 102 | Ok(()) 103 | } 104 | 105 | #[tokio::test] 106 | async fn launch_paseo_and_system_parachain() -> Result<()> { 107 | let temp_dir = tempfile::tempdir()?; 108 | let cache = temp_dir.path().to_path_buf(); 109 | 110 | let mut zombienet = Zombienet::new( 111 | &cache, 112 | Path::new("../../tests/networks/paseo+coretime.toml").try_into()?, 113 | Some(BINARY_VERSION), 114 | None, 115 | Some(BINARY_VERSION), 116 | Some("v1.3.3"), // 1.3.3 is where coretime-paseo-local was introduced. 117 | None, 118 | ) 119 | .await?; 120 | 121 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 122 | binary.source(true, &(), true).await?; 123 | } 124 | 125 | zombienet.spawn().await?; 126 | Ok(()) 127 | } 128 | 129 | #[tokio::test] 130 | async fn launch_paseo_and_two_parachains() -> Result<()> { 131 | let temp_dir = tempfile::tempdir()?; 132 | let cache = temp_dir.path().to_path_buf(); 133 | 134 | let mut zombienet = Zombienet::new( 135 | &cache, 136 | Path::new("../../tests/networks/pop.toml").try_into()?, 137 | Some(BINARY_VERSION), 138 | None, 139 | Some(BINARY_VERSION), 140 | None, 141 | Some(&vec!["https://github.com/r0gue-io/pop-node#node-v0.3.0".to_string()]), 142 | ) 143 | .await?; 144 | 145 | for binary in zombienet.binaries().filter(|b| !b.exists()) { 146 | binary.source(true, &(), true).await?; 147 | } 148 | 149 | zombienet.spawn().await?; 150 | Ok(()) 151 | } 152 | -------------------------------------------------------------------------------- /crates/pop-telemetry/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "pop-telemetry" 3 | description = "Library for collecting anonymous Usage Metrics Collection with Umami." 4 | readme = "README.md" 5 | edition.workspace = true 6 | license.workspace = true 7 | repository.workspace = true 8 | version.workspace = true 9 | 10 | [dependencies] 11 | dirs = { workspace = true } 12 | env_logger.workspace = true 13 | log.workspace = true 14 | reqwest.workspace = true 15 | serde.workspace = true 16 | serde_json.workspace = true 17 | thiserror.workspace = true 18 | tokio.workspace = true 19 | 20 | [dev-dependencies] 21 | mockito.workspace = true 22 | tempfile.workspace = true -------------------------------------------------------------------------------- /crates/pop-telemetry/LICENSE: -------------------------------------------------------------------------------- 1 | ../../LICENSE -------------------------------------------------------------------------------- /crates/pop-telemetry/README.md: -------------------------------------------------------------------------------- 1 | # Telemetry 2 | 3 | Anonymous Usage Metrics Collection with Umami 4 | 5 | ## Umami 6 | 7 | Umami is an analytics platform that is privacy-focused and open-source. It is a great alternative to Google Analytics. 8 | We self-host Umami in the EU to safeguard all anonymous data. 9 | 10 | You can read more about Umami [here](https://umami.is/). 11 | 12 | ## Why Collect Anonymous Usage Metrics? 13 | 14 | We understand the importance of privacy and are committed to safeguarding the data of our users. Collecting 15 | anonymous usage metrics can provide invaluable insights into how our CLI tool is being utilized, allowing us to improve 16 | its performance, reliability, and user experience. Here's why we collect anonymous usage metrics: 17 | 18 | 1. **Improving User Experience**: By understanding how our CLI tool is used in real-world scenarios, we can identify 19 | areas for improvement and prioritize features that will enhance the overall user experience. 20 | 21 | 2. **Bug Identification and Resolution**: Anonymous usage metrics help us identify and prioritize bugs and issues that 22 | may not be immediately apparent. This allows us to provide quicker resolutions and ensure a smoother user experience. 23 | 24 | 3. **Feature Prioritization**: Knowing which features are used most frequently helps us prioritize development efforts 25 | and allocate resources effectively to meet the needs of our users. 26 | 27 | ## What We Collect 28 | 29 | We do **not** collect **any** personal information. We do not collect file names, GitHub repositories, or anything 30 | that is potentially sensitive. We do not even try to collect and sanitize this data, we simply do not collect it. 31 | Here is what we do collect, anonymously: 32 | 33 | 1. **Command Usage**: We collect information about the commands that are executed using our CLI tool. This includes 34 | the type of command and options used. For example, we may report that `pop new parachain` was executed with the Pop 35 | Standard template. 36 | 2. **CLI Usage**: We collect information about how often the CLI tool is used. 37 | 38 | ## Our Commitment to Privacy 39 | 40 | We take privacy seriously and are committed to protecting the anonymity of our users. Here's how we ensure your privacy: 41 | 42 | - **Anonymous Data Collection**: We only collect anonymized usage metrics, which do not contain any personally 43 | identifiable information. 44 | 45 | - **Transparency**: We are transparent about the data we collect and how it is used. Some portions of the data will be 46 | made public, 47 | such as the number of times a command was executed, and total number of users. 48 | 49 | - **Privacy-First Platform**: We use Umami, a privacy-focused and open-source analytics platform, to collect anonymous 50 | usage metrics. 51 | 52 | - **EU and GDPR Compliance**: We self-host Umami in the EU to ensure compliance with the General Data Protection 53 | Regulation (GDPR) and safeguard the data of our users. This ensures there is no 3rd party involved in the data. 54 | 55 | ## How to Opt-Out 56 | 57 | If you prefer not to participate in anonymous usage metrics collection, there are a 58 | few ways you can opt out. We support the [DO_NOT_TRACK](https://consoledonottrack.com/) and CI environment variable 59 | standards. 60 | 61 | 1. Set the `DO_NOT_TRACK` environment variable to `true` or `1` 62 | 2. Set the `CI` environment variable to `true` or `1` 63 | 3. Completely disable telemetry, by installing with telemetry compiled out: 64 | 65 | ```bash 66 | cargo install --locked --no-default-features --features contract,parachain --git "https://github.com/r0gue-io/pop-cli" 67 | ``` 68 | 69 | ## Questions or Concerns? 70 | 71 | If you have any questions or concerns regarding our telemetry practices, please don't 72 | hesitate to contact us: 73 | 74 | - Contact form: [r0gue.io/contact](https://r0gue.io/contact) 75 | - Telegram: [Pop](https://t.me/onpopio) 76 | 77 | Thank you for your support and understanding. 78 | -------------------------------------------------------------------------------- /deny.toml: -------------------------------------------------------------------------------- 1 | [graph] 2 | all-features = false 3 | 4 | # This section is considered when running `cargo deny check advisories` 5 | [advisories] 6 | ignore = [ 7 | { id = "RUSTSEC-2024-0344", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/214" }, 8 | { id = "RUSTSEC-2024-0388", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/436" }, 9 | { id = "RUSTSEC-2024-0384", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/437" }, 10 | { id = "RUSTSEC-2020-0163", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/438" }, 11 | { id = "RUSTSEC-2024-0436", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/450" }, 12 | { id = "RUSTSEC-2025-0012", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/451" }, 13 | { id = "RUSTSEC-2024-0370", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/458" }, 14 | { id = "RUSTSEC-2022-0061", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/458" }, 15 | { id = "RUSTSEC-2020-0168", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/458" }, 16 | { id = "RUSTSEC-2024-0438", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/458" }, 17 | { id = "RUSTSEC-2023-0091", reason = "No upgrade available. Tracking the vulnerability: https://github.com/r0gue-io/pop-cli/issues/458" }, 18 | ] 19 | 20 | [licenses] 21 | allow = [ 22 | "Apache-2.0", 23 | "Apache-2.0 WITH LLVM-exception", 24 | "BSL-1.0", 25 | "BSD-2-Clause", 26 | "BSD-3-Clause", 27 | "CC0-1.0", 28 | "ISC", 29 | "GPL-3.0", 30 | "GPL-3.0 WITH Classpath-exception-2.0", # For Substrate crates 31 | "MIT", 32 | "MPL-2.0", 33 | "Unicode-3.0", 34 | "Unicode-DFS-2016", 35 | "Unlicense", 36 | "Zlib" 37 | ] 38 | confidence-threshold = 0.93 39 | 40 | [[licenses.exceptions]] 41 | allow = ["OpenSSL"] 42 | name = "ring" 43 | 44 | [[licenses.clarify]] 45 | crate = "webpki" 46 | expression = "ISC" 47 | license-files = [ 48 | { path = "LICENSE", hash = 0x001c7e6c }, 49 | ] 50 | 51 | [[licenses.exceptions]] 52 | allow = ["GPL-3.0-or-later WITH Classpath-exception-2.0"] 53 | name = "cumulus-rely-chain-interface" 54 | 55 | [[licenses.clarify]] 56 | name = "ring" 57 | expression = "ISC AND MIT AND OpenSSL" 58 | license-files = [ 59 | { path = "LICENSE", hash = 0xbd0eed23 }, 60 | ] 61 | -------------------------------------------------------------------------------- /rust-toolchain.toml: -------------------------------------------------------------------------------- 1 | [toolchain] 2 | channel = "1.86" 3 | components = [ 4 | "cargo", 5 | "clippy", 6 | "rust-analyzer", 7 | "rust-src", 8 | "rust-std", 9 | "rustc", 10 | "rustfmt", 11 | ] 12 | targets = ["wasm32-unknown-unknown"] 13 | profile = "minimal" 14 | -------------------------------------------------------------------------------- /tests/networks/kusama+asset-hub.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/kusama+asset-hub.toml 2 | 3 | [relaychain] 4 | chain = "kusama-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "asset-hub-kusama-local" 17 | 18 | [[parachains.collators]] 19 | name = "asset-hub" -------------------------------------------------------------------------------- /tests/networks/kusama.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/kusama.toml 2 | 3 | [relaychain] 4 | chain = "kusama-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true -------------------------------------------------------------------------------- /tests/networks/paseo+asset-hub.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo+asset-hub.toml -S v1.3.4 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "asset-hub-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "asset-hub" 20 | args = ["-lxcm=trace,lsystem::events=trace,lruntime=trace"] -------------------------------------------------------------------------------- /tests/networks/paseo+bridge-hub.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo+bridge-hub.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "bridge-hub-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "bridge-hub" 20 | args = ["-lxcm=trace,lsystem::events=trace,lruntime=trace"] -------------------------------------------------------------------------------- /tests/networks/paseo+collectives.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo+collectives.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1004 16 | chain = "collectives-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "collectives" 20 | args = ["-lxcm=trace,lsystem::events=trace,lruntime=trace"] 21 | -------------------------------------------------------------------------------- /tests/networks/paseo+coretime.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo+coretime.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1005 16 | chain = "coretime-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "coretime" 20 | args = ["-lxcm=trace,lsystem::events=trace,lruntime=trace"] -------------------------------------------------------------------------------- /tests/networks/paseo+people.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo+people.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1004 16 | chain = "people-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "people" 20 | args = ["-lxcm=trace,lsystem::events=trace,lruntime=trace"] 21 | -------------------------------------------------------------------------------- /tests/networks/paseo.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/paseo.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true -------------------------------------------------------------------------------- /tests/networks/polkadot+asset-hub.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/polkadot+asset-hub.toml 2 | 3 | [relaychain] 4 | chain = "polkadot-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "asset-hub-polkadot-local" 17 | 18 | [[parachains.collators]] 19 | name = "asset-hub" -------------------------------------------------------------------------------- /tests/networks/polkadot+collectives.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/polkadot.toml 2 | 3 | [relaychain] 4 | chain = "polkadot-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "collectives-polkadot-local" 17 | 18 | [[parachains.collators]] 19 | name = "collectives-01" -------------------------------------------------------------------------------- /tests/networks/polkadot.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/polkadot.toml 2 | 3 | [relaychain] 4 | chain = "polkadot-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true -------------------------------------------------------------------------------- /tests/networks/pop.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/pop.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "asset-hub-paseo-local" 17 | 18 | [[parachains.collators]] 19 | name = "asset-hub" 20 | 21 | [[parachains]] 22 | id = 4385 23 | default_command = "pop-node" 24 | 25 | [[parachains.collators]] 26 | name = "pop" 27 | args = ["-lruntime::contracts=debug"] 28 | 29 | [[hrmp_channels]] 30 | sender = 1000 31 | recipient = 4385 32 | max_capacity = 1000 33 | max_message_size = 5000 34 | 35 | [[hrmp_channels]] 36 | sender = 4385 37 | recipient = 1000 38 | max_capacity = 1000 39 | max_message_size = 8000 -------------------------------------------------------------------------------- /tests/networks/template.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/template.toml 2 | 3 | [relaychain] 4 | chain = "paseo-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 2000 16 | default_command = "./target/release/parachain-template-node" 17 | 18 | [[parachains.collators]] 19 | name = "collator-01" -------------------------------------------------------------------------------- /tests/networks/westend+asset-hub.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/westend+asset-hub.toml 2 | 3 | [relaychain] 4 | chain = "westend-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | 14 | [[parachains]] 15 | id = 1000 16 | chain = "asset-hub-westend-local" 17 | 18 | [[parachains.collators]] 19 | name = "asset-hub" -------------------------------------------------------------------------------- /tests/networks/westend.toml: -------------------------------------------------------------------------------- 1 | # pop up network ./tests/networks/westend.toml 2 | 3 | [relaychain] 4 | chain = "westend-local" 5 | 6 | [[relaychain.nodes]] 7 | name = "alice" 8 | validator = true 9 | 10 | [[relaychain.nodes]] 11 | name = "bob" 12 | validator = true 13 | -------------------------------------------------------------------------------- /tests/runtimes/base_parachain.wasm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/tests/runtimes/base_parachain.wasm -------------------------------------------------------------------------------- /tests/runtimes/base_parachain_benchmark.wasm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/tests/runtimes/base_parachain_benchmark.wasm -------------------------------------------------------------------------------- /tests/runtimes/base_parachain_try_runtime.wasm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/tests/runtimes/base_parachain_try_runtime.wasm -------------------------------------------------------------------------------- /tests/snapshots/base_parachain.snap: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r0gue-io/pop-cli/92b9d02f8c1ce78f3d2b47b77f1b15d09a2fe6c8/tests/snapshots/base_parachain.snap --------------------------------------------------------------------------------
4 |
5 |