feat: initialize Kurdistan SDK - independent fork of Polkadot SDK

templates/minimal/.dockerignore

@@ -0,0 +1,3 @@
+target/
+Dockerfile
+.dockerignore

templates/minimal/Dockerfile

@@ -0,0 +1,28 @@
+FROM docker.io/paritytech/ci-unified:latest as builder
+
+WORKDIR /polkadot
+COPY . /polkadot
+
+RUN cargo fetch
+RUN cargo build --workspace --locked --release
+
+FROM docker.io/parity/base-bin:latest
+
+COPY --from=builder /polkadot/target/release/minimal-template-node /usr/local/bin
+
+USER root
+RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \
+	mkdir -p /data /polkadot/.local/share && \
+	chown -R polkadot:polkadot /data && \
+	ln -s /data /polkadot/.local/share/polkadot && \
+# unclutter and minimize the attack surface
+	rm -rf /usr/bin /usr/sbin && \
+# check if executable works in this container
+	/usr/local/bin/minimal-template-node --version
+
+USER polkadot
+
+EXPOSE 30333 9933 9944 9615
+VOLUME ["/data"]
+
+ENTRYPOINT ["/usr/local/bin/minimal-template-node"]

templates/minimal/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

templates/minimal/README.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+# Pezkuwi SDK's Minimal Template
+
+<img height="70px" alt="Pezkuwi SDK Logo" src="https://github.com/pezkuwichain/pezkuwi-sdk/raw/master/docs/images/PezkuwiChain_Logo_Horizontal_Pink_White.png#gh-dark-mode-only"/>
+<img height="70px" alt="Pezkuwi SDK Logo" src="https://github.com/pezkuwichain/pezkuwi-sdk/raw/master/docs/images/PezkuwiChain_Logo_Horizontal_Pink_Black.png#gh-light-mode-only"/>
+
+> This is a minimal template for creating a blockchain based on Pezkuwi SDK.
+>
+> This template is automatically updated after releases in the main [Pezkuwi SDK monorepo](https://github.com/pezkuwichain/pezkuwi-sdk).
+
+</div>
+
+## Table of Contents
+
+- [Intro](#intro)
+
+- [Template Structure](#template-structure)
+
+- [Getting Started](#getting-started)
+
+- [Starting a Minimal Template Chain](#starting-a-minimal-template-chain)
+
+  - [Minimal Template Node](#minimal-template-node)
+  - [Zombienet with Minimal Template Node](#zombienet-with-minimal-template-node)
+  - [Connect with the PezkuwiChain-JS Apps Front-End](#connect-with-the-pezkuwi-js-apps-front-end)
+  - [Takeaways](#takeaways)
+
+- [Contributing](#contributing)
+
+- [Getting Help](#getting-help)
+
+## Intro
+
+- 🤏 This template is a minimal (in terms of complexity and the number of components)
+template for building a blockchain node.
+
+- 🔧 Its runtime is configured with a single custom pallet as a starting point, and a handful of ready-made pallets
+such as a [Balances pallet](https://docs.pezkuwichain.io/sdk/master/pallet_balances/index.html).
+
+- 👤 The template has no consensus configured - it is best for experimenting with a single node network.
+
+
+## Template Structure
+
+A Pezkuwi SDK based project such as this one consists of:
+
+- 🧮 the [Runtime](./runtime/README.md) - the core logic of the blockchain.
+- 🎨 the [Pallets](./pallets/README.md) - from which the runtime is constructed.
+- 💿 a [Node](./node/README.md) - the binary application (which is not part of the cargo default-members list and is not
+compiled unless building the entire workspace).
+
+## Getting Started
+
+- 🦀 The template is using the Rust language.
+
+- 👉 Check the
+[Rust installation instructions](https://www.rust-lang.org/tools/install) for your system.
+
+- 🛠️ Depending on your operating system and Rust version, there might be additional
+packages required to compile this template - please take note of the Rust compiler output.
+
+Fetch minimal template code.
+
+```sh
+git clone https://github.com/pezkuwichain/pezkuwi-sdk/issues/25.git minimal-template
+
+cd minimal-template
+```
+
+## Starting a Minimal Template Chain
+
+### Minimal Template Node
+
+#### Build both node & runtime
+
+```sh
+cargo build --workspace --release
+```
+
+🐳 Alternatively, build the docker image which builds all the workspace members,
+and has as entry point the node binary:
+
+```sh
+docker build . -t pezkuwi-sdk-minimal-template
+```
+
+#### Start the `minimal-template-node`
+
+The `minimal-template-node` has dependency on the `minimal-template-runtime`. It will use
+the `minimal_template_runtime::WASM_BINARY` constant (which holds the WASM blob as a byte
+array) for chain spec building, while starting.
+
+```sh
+<target/release/path/to/minimal-template-node> --tmp --consensus manual-seal-3000
+# or via docker
+docker run --rm pezkuwi-sdk-minimal-template
+```
+
+#### Zombienet with `minimal-template-node`
+
+For this one we just need to have `zombienet` installed and run:
+
+```sh
+zombienet --provider native spawn zombienet-multi-node.toml
+```
+
+### Connect with the PezkuwiChain-JS Apps Front-End
+
+- 🌐 You can interact with your local node using the
+hosted version of the [PezkuwiChain/Substrate
+Portal](https://pezkuwichain.io/#/explorer?rpc=ws://localhost:9944).
+
+- 🪐 A hosted version is also
+available on [IPFS](https://dotapps.io/).
+
+- 🧑‍🔧 You can also find the source code and instructions for hosting your own instance in the
+[`pezkuwi-js/apps`](https://github.com/polkadot-js/apps) repository.
+
+### Takeaways
+
+Previously minimal template's development chains:
+
+- ❌ Started in a multi-node setup will produce forks because minimal lacks consensus.
+- 🧹 Do not persist the state.
+- 💰 Are pre-configured with a genesis state that includes several pre-funded development accounts.
+- 🧑‍⚖️ One development account (`ALICE`) is used as `sudo` accounts.
+
+## Contributing
+
+- 🔄 This template is automatically updated after releases in the main [Pezkuwi SDK monorepo](https://github.com/pezkuwichain/pezkuwi-sdk).
+
+- ➡️ Any pull requests should be directed to this [source](https://github.com/pezkuwichain/pezkuwi-sdk/tree/master/templates/minimal).
+
+- 😇 Please refer to the monorepo's
+[contribution guidelines](https://github.com/pezkuwichain/pezkuwi-sdk/blob/master/docs/contributor/CONTRIBUTING.md) and
+[Code of Conduct](https://github.com/pezkuwichain/pezkuwi-sdk/blob/master/docs/contributor/CODE_OF_CONDUCT.md).
+
+## Getting Help
+
+- 🧑‍🏫 To learn about PezkuwiChain in general, [docs.PezkuwiChain.com](https://docs.pezkuwichain.app/) website is a good starting point.
+
+- 🧑‍🔧 For technical introduction, [here](https://github.com/pezkuwichain/pezkuwi-sdk#-documentation) are
+the Pezkuwi SDK documentation resources.
+
+- 👥 Additionally, there are [GitHub issues](https://github.com/pezkuwichain/pezkuwi-sdk/issues) and
+[Substrate StackExchange](https://pezkuwichain.app/community/).
+- 👥You can also reach out on the [Official PezkuwiChain discord server](https://polkadot-discord.w3f.tools/)
+- 🧑Reach out on [Telegram](https://t.me/substratedevs) for more questions and discussions

templates/minimal/node/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "minimal-template-node"
+description = "A minimal Substrate-based Substrate node, ready for hacking."
+version = "0.0.0"
+license = "Unlicense"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+edition.workspace = true
+publish = false
+build = "build.rs"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { features = ["derive"], workspace = true }
+docify = { workspace = true }
+futures = { features = ["thread-pool"], workspace = true }
+futures-timer = { workspace = true }
+jsonrpsee = { features = ["server"], workspace = true }
+
+minimal-template-runtime = { workspace = true }
+pezkuwi-sdk = { workspace = true, features = ["experimental", "node"] }
+
+[build-dependencies]
+pezkuwi-sdk = { workspace = true, features = ["substrate-build-script-utils"] }
+
+[features]
+default = ["std"]
+std = ["minimal-template-runtime/std", "pezkuwi-sdk/std"]
+runtime-benchmarks = [
+	"minimal-template-runtime/runtime-benchmarks",
+	"pezkuwi-sdk/runtime-benchmarks",
+]

templates/minimal/node/README.md

@@ -0,0 +1,18 @@
+# Node
+
+ℹ️ A node -  in PezkuwiChain - is a binary executable, whose primary purpose is to execute the [runtime](../runtime/README.md).
+
+🔗 It communicates with other nodes in the network, and aims for
+[consensus](https://docs.pezkuwichain.app/polkadot-protocol/architecture/polkadot-chain/pos-consensus/) among them.
+
+⚙️ It acts as a remote procedure call (RPC) server, allowing interaction with the blockchain.
+
+👉 Learn more about the architecture, and a difference between a node and a runtime
+[here](https://docs.pezkuwichain.io/sdk/master/polkadot_sdk_docs/reference_docs/wasm_meta_protocol/index.html).
+
+👇 Here are the most important files in this node template:
+
+- [`chain_spec.rs`](./src/chain_spec.rs): A chain specification is a source code file that defines the chain's
+initial (genesis) state.
+- [`service.rs`](./src/service.rs): This file defines the node implementation.
+It's a place to configure consensus-related topics. In favor of minimalism, this template has no consensus configured.

templates/minimal/node/build.rs

@@ -0,0 +1,23 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use pezkuwi_sdk::substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed};
+
+fn main() {
+	generate_cargo_keys();
+	rerun_if_git_head_changed();
+}

templates/minimal/node/src/chain_spec.rs

@@ -0,0 +1,42 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use minimal_template_runtime::WASM_BINARY;
+use pezkuwi_sdk::{
+	sc_service::{ChainType, Properties},
+	*,
+};
+
+/// This is a specialization of the general Substrate ChainSpec type.
+pub type ChainSpec = sc_service::GenericChainSpec;
+
+fn props() -> Properties {
+	let mut properties = Properties::new();
+	properties.insert("tokenDecimals".to_string(), 0.into());
+	properties.insert("tokenSymbol".to_string(), "MINI".into());
+	properties
+}
+
+pub fn development_chain_spec() -> Result<ChainSpec, String> {
+	Ok(ChainSpec::builder(WASM_BINARY.expect("Development wasm not available"), Default::default())
+		.with_name("Development")
+		.with_id("dev")
+		.with_chain_type(ChainType::Development)
+		.with_genesis_config_preset_name(sp_genesis_builder::DEV_RUNTIME_PRESET)
+		.with_properties(props())
+		.build())
+}

templates/minimal/node/src/cli.rs

@@ -0,0 +1,92 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use pezkuwi_sdk::*;
+
+#[derive(Debug, Clone)]
+pub enum Consensus {
+	ManualSeal(u64),
+	InstantSeal,
+	None,
+}
+
+impl std::str::FromStr for Consensus {
+	type Err = String;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		Ok(if s == "instant-seal" {
+			Consensus::InstantSeal
+		} else if let Some(block_time) = s.strip_prefix("manual-seal-") {
+			Consensus::ManualSeal(block_time.parse().map_err(|_| "invalid block time")?)
+		} else if s.to_lowercase() == "none" {
+			Consensus::None
+		} else {
+			return Err("incorrect consensus identifier".into());
+		})
+	}
+}
+
+#[derive(Debug, clap::Parser)]
+pub struct Cli {
+	#[command(subcommand)]
+	pub subcommand: Option<Subcommand>,
+
+	#[clap(long, default_value = "manual-seal-3000")]
+	pub consensus: Consensus,
+
+	#[clap(flatten)]
+	pub run: sc_cli::RunCmd,
+}
+
+#[derive(Debug, clap::Subcommand)]
+pub enum Subcommand {
+	/// Key management cli utilities
+	#[command(subcommand)]
+	Key(sc_cli::KeySubcommand),
+
+	/// Build a chain specification.
+	/// DEPRECATED: `build-spec` command will be removed after 1/04/2026. Use `export-chain-spec`
+	/// command instead.
+	#[deprecated(
+		note = "build-spec command will be removed after 1/04/2026. Use export-chain-spec command instead"
+	)]
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Export the chain specification.
+	ExportChainSpec(sc_cli::ExportChainSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
+
+	/// Db meta columns information.
+	ChainInfo(sc_cli::ChainInfoCmd),
+}

templates/minimal/node/src/command.rs

@@ -0,0 +1,137 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::{
+	chain_spec,
+	cli::{Cli, Subcommand},
+	service,
+};
+use pezkuwi_sdk::{sc_cli::SubstrateCli, sc_service::PartialComponents, *};
+
+impl SubstrateCli for Cli {
+	fn impl_name() -> String {
+		"Substrate Node".into()
+	}
+
+	fn impl_version() -> String {
+		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
+	}
+
+	fn description() -> String {
+		env!("CARGO_PKG_DESCRIPTION").into()
+	}
+
+	fn author() -> String {
+		env!("CARGO_PKG_AUTHORS").into()
+	}
+
+	fn support_url() -> String {
+		"support.anonymous.an".into()
+	}
+
+	fn copyright_start_year() -> i32 {
+		2017
+	}
+
+	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+		Ok(match id {
+			"dev" => Box::new(chain_spec::development_chain_spec()?),
+			path =>
+				Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?),
+		})
+	}
+}
+
+/// Parse and run command line arguments
+pub fn run() -> sc_cli::Result<()> {
+	let cli = Cli::from_args();
+
+	match &cli.subcommand {
+		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+		#[allow(deprecated)]
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		},
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					service::new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::ExportChainSpec(cmd)) => {
+			let chain_spec = cli.load_spec(&cmd.chain)?;
+			cmd.run(chain_spec)
+		},
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		},
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		},
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					service::new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		},
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, backend, .. } =
+					service::new_partial(&config)?;
+				Ok((cmd.run(client, backend, None), task_manager))
+			})
+		},
+		Some(Subcommand::ChainInfo(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| {
+				cmd.run::<minimal_template_runtime::interface::OpaqueBlock>(&config)
+			})
+		},
+		None => {
+			let runner = cli.create_runner(&cli.run)?;
+			runner.run_node_until_exit(|config| async move {
+				match config.network.network_backend {
+					sc_network::config::NetworkBackendType::Libp2p =>
+						service::new_full::<sc_network::NetworkWorker<_, _>>(config, cli.consensus)
+							.map_err(sc_cli::Error::Service),
+					sc_network::config::NetworkBackendType::Litep2p => service::new_full::<
+						sc_network::Litep2pNetworkBackend,
+					>(config, cli.consensus)
+					.map_err(sc_cli::Error::Service),
+				}
+			})
+		},
+	}
+}

templates/minimal/node/src/lib.rs

@@ -0,0 +1,21 @@
+// This file is part of Pezkuwi Sdk.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+pub mod chain_spec;
+pub(crate) mod cli;
+pub mod rpc;
+pub mod service;

templates/minimal/node/src/main.rs

@@ -0,0 +1,29 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Substrate Node Template CLI library.
+#![warn(missing_docs)]
+
+mod chain_spec;
+mod cli;
+mod command;
+mod rpc;
+mod service;
+
+fn main() -> pezkuwi_sdk::sc_cli::Result<()> {
+	command::run()
+}

templates/minimal/node/src/rpc.rs

@@ -0,0 +1,66 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A collection of node-specific RPC methods.
+//! Substrate provides the `sc-rpc` crate, which defines the core RPC layer
+//! used by Substrate nodes. This file extends those RPC definitions with
+//! capabilities that are specific to this project's runtime configuration.
+
+#![warn(missing_docs)]
+
+use jsonrpsee::RpcModule;
+use minimal_template_runtime::interface::{AccountId, Nonce, OpaqueBlock};
+use pezkuwi_sdk::{
+	sc_transaction_pool_api::TransactionPool,
+	sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata},
+	*,
+};
+use std::sync::Arc;
+
+/// Full client dependencies.
+pub struct FullDeps<C, P> {
+	/// The client instance to use.
+	pub client: Arc<C>,
+	/// Transaction pool instance.
+	pub pool: Arc<P>,
+}
+
+#[docify::export]
+/// Instantiate all full RPC extensions.
+pub fn create_full<C, P>(
+	deps: FullDeps<C, P>,
+) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
+where
+	C: Send
+		+ Sync
+		+ 'static
+		+ sp_api::ProvideRuntimeApi<OpaqueBlock>
+		+ HeaderBackend<OpaqueBlock>
+		+ HeaderMetadata<OpaqueBlock, Error = BlockChainError>
+		+ 'static,
+	C::Api: sp_block_builder::BlockBuilder<OpaqueBlock>,
+	C::Api: substrate_frame_rpc_system::AccountNonceApi<OpaqueBlock, AccountId, Nonce>,
+	P: TransactionPool + 'static,
+{
+	use pezkuwi_sdk::substrate_frame_rpc_system::{System, SystemApiServer};
+	let mut module = RpcModule::new(());
+	let FullDeps { client, pool } = deps;
+
+	module.merge(System::new(client.clone(), pool.clone()).into_rpc())?;
+
+	Ok(module)
+}

templates/minimal/node/src/service.rs

@@ -0,0 +1,269 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::cli::Consensus;
+use futures::FutureExt;
+use minimal_template_runtime::{interface::OpaqueBlock as Block, RuntimeApi};
+use pezkuwi_sdk::{
+	sc_client_api::backend::Backend,
+	sc_executor::WasmExecutor,
+	sc_service::{error::Error as ServiceError, Configuration, TaskManager},
+	sc_telemetry::{Telemetry, TelemetryWorker},
+	sc_transaction_pool_api::OffchainTransactionPoolFactory,
+	sp_runtime::traits::Block as BlockT,
+	*,
+};
+use std::sync::Arc;
+
+type HostFunctions = sp_io::SubstrateHostFunctions;
+
+#[docify::export]
+pub(crate) type FullClient =
+	sc_service::TFullClient<Block, RuntimeApi, WasmExecutor<HostFunctions>>;
+
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
+
+/// Assembly of PartialComponents (enough to run chain ops subcommands)
+pub type Service = sc_service::PartialComponents<
+	FullClient,
+	FullBackend,
+	FullSelectChain,
+	sc_consensus::DefaultImportQueue<Block>,
+	sc_transaction_pool::TransactionPoolHandle<Block, FullClient>,
+	Option<Telemetry>,
+>;
+
+pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
+	let executor = sc_service::new_wasm_executor(&config.executor);
+
+	let (client, backend, keystore_container, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, _>(
+			config,
+			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+			executor,
+		)?;
+	let client = Arc::new(client);
+
+	let telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", None, worker.run());
+		telemetry
+	});
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = Arc::from(
+		sc_transaction_pool::Builder::new(
+			task_manager.spawn_essential_handle(),
+			client.clone(),
+			config.role.is_authority().into(),
+		)
+		.with_options(config.transaction_pool.clone())
+		.with_prometheus(config.prometheus_registry())
+		.build(),
+	);
+
+	let import_queue = sc_consensus_manual_seal::import_queue(
+		Box::new(client.clone()),
+		&task_manager.spawn_essential_handle(),
+		config.prometheus_registry(),
+	);
+
+	Ok(sc_service::PartialComponents {
+		client,
+		backend,
+		task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		other: (telemetry),
+	})
+}
+
+/// Builds a new service for a full client.
+pub fn new_full<Network: sc_network::NetworkBackend<Block, <Block as BlockT>::Hash>>(
+	config: Configuration,
+	consensus: Consensus,
+) -> Result<TaskManager, ServiceError> {
+	let sc_service::PartialComponents {
+		client,
+		backend,
+		mut task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		other: mut telemetry,
+	} = new_partial(&config)?;
+
+	let net_config = sc_network::config::FullNetworkConfiguration::<
+		Block,
+		<Block as BlockT>::Hash,
+		Network,
+	>::new(
+		&config.network,
+		config.prometheus_config.as_ref().map(|cfg| cfg.registry.clone()),
+	);
+	let metrics = Network::register_notification_metrics(
+		config.prometheus_config.as_ref().map(|cfg| &cfg.registry),
+	);
+
+	let (network, system_rpc_tx, tx_handler_controller, sync_service) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			net_config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			block_announce_validator_builder: None,
+			warp_sync_config: None,
+			block_relay: None,
+			metrics,
+		})?;
+
+	if config.offchain_worker.enabled {
+		let offchain_workers =
+			sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
+				runtime_api_provider: client.clone(),
+				is_validator: config.role.is_authority(),
+				keystore: Some(keystore_container.keystore()),
+				offchain_db: backend.offchain_storage(),
+				transaction_pool: Some(OffchainTransactionPoolFactory::new(
+					transaction_pool.clone(),
+				)),
+				network_provider: Arc::new(network.clone()),
+				enable_http_requests: true,
+				custom_extensions: |_| vec![],
+			})?;
+		task_manager.spawn_handle().spawn(
+			"offchain-workers-runner",
+			"offchain-worker",
+			offchain_workers.run(client.clone(), task_manager.spawn_handle()).boxed(),
+		);
+	}
+
+	let rpc_extensions_builder = {
+		let client = client.clone();
+		let pool = transaction_pool.clone();
+
+		Box::new(move |_| {
+			let deps = crate::rpc::FullDeps { client: client.clone(), pool: pool.clone() };
+			crate::rpc::create_full(deps).map_err(Into::into)
+		})
+	};
+
+	let prometheus_registry = config.prometheus_registry().cloned();
+
+	let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		network,
+		client: client.clone(),
+		keystore: keystore_container.keystore(),
+		task_manager: &mut task_manager,
+		transaction_pool: transaction_pool.clone(),
+		rpc_builder: rpc_extensions_builder,
+		backend,
+		system_rpc_tx,
+		tx_handler_controller,
+		sync_service,
+		config,
+		telemetry: telemetry.as_mut(),
+		tracing_execute_block: None,
+	})?;
+
+	let proposer = sc_basic_authorship::ProposerFactory::new(
+		task_manager.spawn_handle(),
+		client.clone(),
+		transaction_pool.clone(),
+		prometheus_registry.as_ref(),
+		telemetry.as_ref().map(|x| x.handle()),
+	);
+
+	match consensus {
+		Consensus::InstantSeal => {
+			let params = sc_consensus_manual_seal::InstantSealParams {
+				block_import: client.clone(),
+				env: proposer,
+				client,
+				pool: transaction_pool,
+				select_chain,
+				consensus_data_provider: None,
+				create_inherent_data_providers: move |_, ()| async move {
+					Ok(sp_timestamp::InherentDataProvider::from_system_time())
+				},
+			};
+
+			let authorship_future = sc_consensus_manual_seal::run_instant_seal(params);
+
+			task_manager.spawn_essential_handle().spawn_blocking(
+				"instant-seal",
+				None,
+				authorship_future,
+			);
+		},
+		Consensus::ManualSeal(block_time) => {
+			let (mut sink, commands_stream) = futures::channel::mpsc::channel(1024);
+			task_manager.spawn_handle().spawn("block_authoring", None, async move {
+				loop {
+					futures_timer::Delay::new(std::time::Duration::from_millis(block_time)).await;
+					sink.try_send(sc_consensus_manual_seal::EngineCommand::SealNewBlock {
+						create_empty: true,
+						finalize: true,
+						parent_hash: None,
+						sender: None,
+					})
+					.unwrap();
+				}
+			});
+
+			let params = sc_consensus_manual_seal::ManualSealParams {
+				block_import: client.clone(),
+				env: proposer,
+				client,
+				pool: transaction_pool,
+				select_chain,
+				commands_stream: Box::pin(commands_stream),
+				consensus_data_provider: None,
+				create_inherent_data_providers: move |_, ()| async move {
+					Ok(sp_timestamp::InherentDataProvider::from_system_time())
+				},
+			};
+			let authorship_future = sc_consensus_manual_seal::run_manual_seal(params);
+
+			task_manager.spawn_essential_handle().spawn_blocking(
+				"manual-seal",
+				None,
+				authorship_future,
+			);
+		},
+		_ => {},
+	}
+
+	Ok(task_manager)
+}

templates/minimal/pallets/README.md

@@ -0,0 +1,13 @@
+# Pallets
+
+ℹ️ A pallet is a unit of encapsulated logic, with a clearly defined responsibility. A pallet is analogous to a
+module in the runtime.
+
+💁 In this template, there is a simple custom pallet based on the FRAME framework.
+
+👉 Learn more about FRAME
+[here](https://docs.pezkuwichain.io/sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).
+
+🧑‍🏫 Please refer to
+[this guide](https://docs.pezkuwichain.io/sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html)
+to learn how to write a basic pallet.

templates/minimal/pallets/template/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "pallet-minimal-template"
+description = "A minimal pallet built with FRAME, part of Pezkuwi Sdk."
+version = "0.0.0"
+license = "Unlicense"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+edition.workspace = true
+publish = false
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { features = ["derive"], workspace = true }
+pezkuwi-sdk = { workspace = true, default-features = false, features = [
+	"experimental",
+	"runtime",
+] }
+scale-info = { features = ["derive"], workspace = true }
+
+[features]
+default = ["std"]
+std = ["codec/std", "pezkuwi-sdk/std", "scale-info/std"]
+runtime-benchmarks = ["pezkuwi-sdk/runtime-benchmarks"]

templates/minimal/pallets/template/src/lib.rs

@@ -0,0 +1,26 @@
+//! A shell pallet built with [`frame`].
+//!
+//! To get started with this pallet, try implementing the guide in
+//! <https://docs.pezkuwichain.io/sdk/master/polkadot_sdk_docs/guides/your_first_pallet/index.html>
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame::prelude::*;
+use pezkuwi_sdk::pezkuwi_sdk_frame as frame;
+
+// Re-export all pallet parts, this is needed to properly import the pallet into the runtime.
+pub use pallet::*;
+
+#[frame::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: pezkuwi_sdk::frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub type Value<T> = StorageValue<Value = u32>;
+}

templates/minimal/runtime/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "minimal-template-runtime"
+description = "A solochain runtime template built with Substrate, part of Pezkuwi Sdk."
+version = "0.0.0"
+license = "Unlicense"
+authors.workspace = true
+homepage.workspace = true
+repository.workspace = true
+edition.workspace = true
+publish = false
+
+[lints]
+workspace = true
+
+[dependencies]
+codec = { workspace = true }
+pezkuwi-sdk = { workspace = true, features = [
+	"pallet-balances",
+	"pallet-sudo",
+	"pallet-timestamp",
+	"pallet-transaction-payment",
+	"pallet-transaction-payment-rpc-runtime-api",
+	"runtime",
+] }
+scale-info = { workspace = true }
+serde_json = { workspace = true, default-features = false, features = [
+	"alloc",
+] }
+
+# local pallet templates
+pallet-minimal-template = { workspace = true }
+
+[build-dependencies]
+pezkuwi-sdk = { optional = true, workspace = true, features = [
+	"substrate-wasm-builder",
+] }
+
+[features]
+default = ["std"]
+std = [
+	"codec/std",
+	"pallet-minimal-template/std",
+	"pezkuwi-sdk/std",
+	"scale-info/std",
+	"serde_json/std",
+]
+runtime-benchmarks = [
+	"pallet-minimal-template/runtime-benchmarks",
+	"pezkuwi-sdk/runtime-benchmarks",
+]

templates/minimal/runtime/README.md

@@ -0,0 +1,10 @@
+# Runtime
+
+ℹ️ The runtime (in other words, a state transition function), refers to the core logic of the blockchain that is
+responsible for validating blocks and executing the state changes they define.
+
+💁 The runtime in this template is constructed using ready-made FRAME pallets that ship with
+[Pezkuwi SDK](https://github.com/pezkuwichain/pezkuwi-sdk), and a [template for a custom pallet](../pallets/README.md).
+
+👉 Learn more about FRAME
+[here](https://docs.pezkuwichain.io/sdk/master/polkadot_sdk_docs/polkadot_sdk/frame_runtime/index.html).

templates/minimal/runtime/build.rs

@@ -0,0 +1,23 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+fn main() {
+	#[cfg(feature = "std")]
+	{
+		pezkuwi_sdk::substrate_wasm_builder::WasmBuilder::build_using_defaults();
+	}
+}

templates/minimal/runtime/src/lib.rs

@@ -0,0 +1,351 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! A minimal runtime that includes the template [`pallet`](`pallet_minimal_template`).
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
+use pezkuwi_sdk::{
+	pezkuwi_sdk_frame::{
+		self as frame,
+		deps::sp_genesis_builder,
+		runtime::{apis, prelude::*},
+	},
+	*,
+};
+
+/// Provides getters for genesis configuration presets.
+pub mod genesis_config_presets {
+	use super::*;
+	use crate::{
+		interface::{Balance, MinimumBalance},
+		sp_keyring::Sr25519Keyring,
+		BalancesConfig, RuntimeGenesisConfig, SudoConfig,
+	};
+
+	use alloc::{vec, vec::Vec};
+	use serde_json::Value;
+
+	/// Returns a development genesis config preset.
+	pub fn development_config_genesis() -> Value {
+		let endowment = <MinimumBalance as Get<Balance>>::get().max(1) * 1000;
+		frame_support::build_struct_json_patch!(RuntimeGenesisConfig {
+			balances: BalancesConfig {
+				balances: Sr25519Keyring::iter()
+					.map(|a| (a.to_account_id(), endowment))
+					.collect::<Vec<_>>(),
+			},
+			sudo: SudoConfig { key: Some(Sr25519Keyring::Alice.to_account_id()) },
+		})
+	}
+
+	/// Get the set of the available genesis config presets.
+	pub fn get_preset(id: &PresetId) -> Option<Vec<u8>> {
+		let patch = match id.as_ref() {
+			sp_genesis_builder::DEV_RUNTIME_PRESET => development_config_genesis(),
+			_ => return None,
+		};
+		Some(
+			serde_json::to_string(&patch)
+				.expect("serialization to json is expected to work. qed.")
+				.into_bytes(),
+		)
+	}
+
+	/// List of supported presets.
+	pub fn preset_names() -> Vec<PresetId> {
+		vec![PresetId::from(sp_genesis_builder::DEV_RUNTIME_PRESET)]
+	}
+}
+
+/// The runtime version.
+#[runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: alloc::borrow::Cow::Borrowed("minimal-template-runtime"),
+	impl_name: alloc::borrow::Cow::Borrowed("minimal-template-runtime"),
+	authoring_version: 1,
+	spec_version: 0,
+	impl_version: 1,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 1,
+	system_version: 1,
+};
+
+/// The version information used to identify this runtime when compiled natively.
+#[cfg(feature = "std")]
+pub fn native_version() -> NativeVersion {
+	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+}
+
+/// The transaction extensions that are added to the runtime.
+type TxExtension = (
+	// Authorize calls that validate themselves.
+	frame_system::AuthorizeCall<Runtime>,
+	// Checks that the sender is not the zero address.
+	frame_system::CheckNonZeroSender<Runtime>,
+	// Checks that the runtime version is correct.
+	frame_system::CheckSpecVersion<Runtime>,
+	// Checks that the transaction version is correct.
+	frame_system::CheckTxVersion<Runtime>,
+	// Checks that the genesis hash is correct.
+	frame_system::CheckGenesis<Runtime>,
+	// Checks that the era is valid.
+	frame_system::CheckEra<Runtime>,
+	// Checks that the nonce is valid.
+	frame_system::CheckNonce<Runtime>,
+	// Checks that the weight is valid.
+	frame_system::CheckWeight<Runtime>,
+	// Ensures that the sender has enough funds to pay for the transaction
+	// and deducts the fee from the sender's account.
+	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+	// Reclaim the unused weight from the block using post dispatch information.
+	// It must be last in the pipeline in order to catch the refund in previous transaction
+	// extensions
+	frame_system::WeightReclaim<Runtime>,
+);
+
+// Composes the runtime by adding all the used pallets and deriving necessary types.
+#[frame_construct_runtime]
+mod runtime {
+	/// The main runtime type.
+	#[runtime::runtime]
+	#[runtime::derive(
+		RuntimeCall,
+		RuntimeEvent,
+		RuntimeError,
+		RuntimeOrigin,
+		RuntimeFreezeReason,
+		RuntimeHoldReason,
+		RuntimeSlashReason,
+		RuntimeLockId,
+		RuntimeTask,
+		RuntimeViewFunction
+	)]
+	pub struct Runtime;
+
+	/// Mandatory system pallet that should always be included in a FRAME runtime.
+	#[runtime::pallet_index(0)]
+	pub type System = frame_system::Pallet<Runtime>;
+
+	/// Provides a way for consensus systems to set and check the onchain time.
+	#[runtime::pallet_index(1)]
+	pub type Timestamp = pallet_timestamp::Pallet<Runtime>;
+
+	/// Provides the ability to keep track of balances.
+	#[runtime::pallet_index(2)]
+	pub type Balances = pallet_balances::Pallet<Runtime>;
+
+	/// Provides a way to execute privileged functions.
+	#[runtime::pallet_index(3)]
+	pub type Sudo = pallet_sudo::Pallet<Runtime>;
+
+	/// Provides the ability to charge for extrinsic execution.
+	#[runtime::pallet_index(4)]
+	pub type TransactionPayment = pallet_transaction_payment::Pallet<Runtime>;
+
+	/// A minimal pallet template.
+	#[runtime::pallet_index(5)]
+	pub type Template = pallet_minimal_template::Pallet<Runtime>;
+}
+
+parameter_types! {
+	pub const Version: RuntimeVersion = VERSION;
+}
+
+/// Implements the types required for the system pallet.
+#[derive_impl(frame_system::config_preludes::SolochainDefaultConfig)]
+impl frame_system::Config for Runtime {
+	type Block = Block;
+	type Version = Version;
+	// Use the account data from the balances pallet
+	type AccountData = pallet_balances::AccountData<<Runtime as pallet_balances::Config>::Balance>;
+}
+
+// Implements the types required for the balances pallet.
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+impl pallet_balances::Config for Runtime {
+	type AccountStore = System;
+}
+
+// Implements the types required for the sudo pallet.
+#[derive_impl(pallet_sudo::config_preludes::TestDefaultConfig)]
+impl pallet_sudo::Config for Runtime {}
+
+// Implements the types required for the sudo pallet.
+#[derive_impl(pallet_timestamp::config_preludes::TestDefaultConfig)]
+impl pallet_timestamp::Config for Runtime {}
+
+// Implements the types required for the transaction payment pallet.
+#[derive_impl(pallet_transaction_payment::config_preludes::TestDefaultConfig)]
+impl pallet_transaction_payment::Config for Runtime {
+	type OnChargeTransaction = pallet_transaction_payment::FungibleAdapter<Balances, ()>;
+	// Setting fee as independent of the weight of the extrinsic for demo purposes
+	type WeightToFee = NoFee<<Self as pallet_balances::Config>::Balance>;
+	// Setting fee as fixed for any length of the call data for demo purposes
+	type LengthToFee = FixedFee<1, <Self as pallet_balances::Config>::Balance>;
+}
+
+// Implements the types required for the template pallet.
+impl pallet_minimal_template::Config for Runtime {}
+
+type Block = frame::runtime::types_common::BlockOf<Runtime, TxExtension>;
+type Header = HeaderFor<Runtime>;
+
+type RuntimeExecutive =
+	Executive<Runtime, Block, frame_system::ChainContext<Runtime>, Runtime, AllPalletsWithSystem>;
+
+impl_runtime_apis! {
+	impl apis::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			VERSION
+		}
+
+		fn execute_block(block: <Block as frame::traits::Block>::LazyBlock) {
+			RuntimeExecutive::execute_block(block)
+		}
+
+		fn initialize_block(header: &Header) -> ExtrinsicInclusionMode {
+			RuntimeExecutive::initialize_block(header)
+		}
+	}
+	impl apis::Metadata<Block> for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			OpaqueMetadata::new(Runtime::metadata().into())
+		}
+
+		fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
+			Runtime::metadata_at_version(version)
+		}
+
+		fn metadata_versions() -> Vec<u32> {
+			Runtime::metadata_versions()
+		}
+	}
+
+	impl apis::BlockBuilder<Block> for Runtime {
+		fn apply_extrinsic(extrinsic: ExtrinsicFor<Runtime>) -> ApplyExtrinsicResult {
+			RuntimeExecutive::apply_extrinsic(extrinsic)
+		}
+
+		fn finalize_block() -> HeaderFor<Runtime> {
+			RuntimeExecutive::finalize_block()
+		}
+
+		fn inherent_extrinsics(data: InherentData) -> Vec<ExtrinsicFor<Runtime>> {
+			data.create_extrinsics()
+		}
+
+		fn check_inherents(
+			block: <Block as frame::traits::Block>::LazyBlock,
+			data: InherentData,
+		) -> CheckInherentsResult {
+			data.check_extrinsics(&block)
+		}
+	}
+
+	impl apis::TaggedTransactionQueue<Block> for Runtime {
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: ExtrinsicFor<Runtime>,
+			block_hash: <Runtime as frame_system::Config>::Hash,
+		) -> TransactionValidity {
+			RuntimeExecutive::validate_transaction(source, tx, block_hash)
+		}
+	}
+
+	impl apis::OffchainWorkerApi<Block> for Runtime {
+		fn offchain_worker(header: &HeaderFor<Runtime>) {
+			RuntimeExecutive::offchain_worker(header)
+		}
+	}
+
+	impl apis::SessionKeys<Block> for Runtime {
+		fn generate_session_keys(_seed: Option<Vec<u8>>) -> Vec<u8> {
+			Default::default()
+		}
+
+		fn decode_session_keys(
+			_encoded: Vec<u8>,
+		) -> Option<Vec<(Vec<u8>, apis::KeyTypeId)>> {
+			Default::default()
+		}
+	}
+
+	impl apis::AccountNonceApi<Block, interface::AccountId, interface::Nonce> for Runtime {
+		fn account_nonce(account: interface::AccountId) -> interface::Nonce {
+			System::account_nonce(account)
+		}
+	}
+
+	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
+		Block,
+		interface::Balance,
+	> for Runtime {
+		fn query_info(uxt: ExtrinsicFor<Runtime>, len: u32) -> RuntimeDispatchInfo<interface::Balance> {
+			TransactionPayment::query_info(uxt, len)
+		}
+		fn query_fee_details(uxt: ExtrinsicFor<Runtime>, len: u32) -> FeeDetails<interface::Balance> {
+			TransactionPayment::query_fee_details(uxt, len)
+		}
+		fn query_weight_to_fee(weight: Weight) -> interface::Balance {
+			TransactionPayment::weight_to_fee(weight)
+		}
+		fn query_length_to_fee(length: u32) -> interface::Balance {
+			TransactionPayment::length_to_fee(length)
+		}
+	}
+
+	impl apis::GenesisBuilder<Block> for Runtime {
+		fn build_state(config: Vec<u8>) -> sp_genesis_builder::Result {
+			build_state::<RuntimeGenesisConfig>(config)
+		}
+
+		fn get_preset(id: &Option<PresetId>) -> Option<Vec<u8>> {
+			get_preset::<RuntimeGenesisConfig>(id, self::genesis_config_presets::get_preset)
+		}
+
+		fn preset_names() -> Vec<PresetId> {
+			self::genesis_config_presets::preset_names()
+		}
+	}
+}
+
+/// Some re-exports that the node side code needs to know. Some are useful in this context as well.
+///
+/// Other types should preferably be private.
+// TODO: this should be standardized in some way, see:
+// https://github.com/paritytech/substrate/issues/10579#issuecomment-1600537558
+pub mod interface {
+	use super::Runtime;
+	use pezkuwi_sdk::{pezkuwi_sdk_frame as frame, *};
+
+	pub type Block = super::Block;
+	pub use frame::runtime::types_common::OpaqueBlock;
+	pub type AccountId = <Runtime as frame_system::Config>::AccountId;
+	pub type Nonce = <Runtime as frame_system::Config>::Nonce;
+	pub type Hash = <Runtime as frame_system::Config>::Hash;
+	pub type Balance = <Runtime as pallet_balances::Config>::Balance;
+	pub type MinimumBalance = <Runtime as pallet_balances::Config>::ExistentialDeposit;
+}

templates/minimal/zombienet.toml

@@ -0,0 +1,30 @@
+# The setup bellow allows only one node to produce
+# blocks and the rest will follow.
+
+[relaychain]
+chain = "dev"
+default_command = "minimal-template-node"
+
+[[relaychain.nodes]]
+name = "alice"
+args = ["--consensus manual-seal-3000"]
+validator = true
+ws_port = 9944
+
+[[relaychain.nodes]]
+name = "bob"
+args = ["--consensus None"]
+validator = true
+ws_port = 9955
+
+[[relaychain.nodes]]
+name = "charlie"
+args = ["--consensus None"]
+validator = true
+ws_port = 9966
+
+[[relaychain.nodes]]
+name = "dave"
+args = ["--consensus None"]
+validator = true
+ws_port = 9977