,
+ /// Whether to deny unsafe calls
+ pub deny_unsafe: DenyUnsafe,
+}
+
+/// Instantiate all full RPC extensions.
+pub fn create_full
@@ -15,7 +15,7 @@ also try out one of the [tutorials](https://substrate.dev/en/tutorials).
## Contributions & Code of Conduct
-Please follow the contributions guidelines as outlined in [`docs/CONTRIBUTING.adoc`](docs/CONTRIBUTING.adoc). In all communications and contributions, this project follows the [Contributor Covenant Code of Conduct](docs/CODE_OF_CONDUCT.adoc).
+Please follow the contributions guidelines as outlined in [`docs/CONTRIBUTING.adoc`](docs/CONTRIBUTING.adoc). In all communications and contributions, this project follows the [Contributor Covenant Code of Conduct](docs/CODE_OF_CONDUCT.md).
## Security
diff --git a/bin/node-template/README.md b/bin/node-template/README.md
index c1730d51e5c13..8c8b82a14bb86 100644
--- a/bin/node-template/README.md
+++ b/bin/node-template/README.md
@@ -1,22 +1,30 @@
# Substrate Node Template
-A new FRAME-based Substrate node, ready for hacking.
+A new FRAME-based Substrate node, ready for hacking :rocket:
-## Build
+## Local Development
-Install Rust:
+Follow these steps to prepare a local Substrate development environment :hammer_and_wrench:
-```bash
-curl https://sh.rustup.rs -sSf | sh
-```
+### Simple Setup
-Initialize your Wasm Build environment:
+Install all the required dependencies with a single command (be patient, this can take up to 30
+minutes).
```bash
-./scripts/init.sh
+curl https://getsubstrate.io -sSf | bash -s -- --fast
```
-Build Wasm and native code:
+### Manual Setup
+
+Find manual setup instructions at the
+[Substrate Developer Hub](https://substrate.dev/docs/en/knowledgebase/getting-started/#manual-installation).
+
+### Build
+
+Once the development environment is set up, build the node template. This command will build the
+[Wasm](https://substrate.dev/docs/en/knowledgebase/advanced/executor#wasm-execution) and
+[native](https://substrate.dev/docs/en/knowledgebase/advanced/executor#native-execution) code:
```bash
cargo build --release
@@ -24,31 +32,38 @@ cargo build --release
## Run
-### Single node development chain
+### Single Node Development Chain
-Purge any existing developer chain state:
+Purge any existing dev chain state:
```bash
./target/release/node-template purge-chain --dev
```
-Start a development chain with:
+Start a dev chain:
```bash
./target/release/node-template --dev
```
-Detailed logs may be shown by running the node with the following environment variables set: `RUST_LOG=debug RUST_BACKTRACE=1 cargo run -- --dev`.
+Or, start a dev chain with detailed logging:
-### Multi-node local testnet
+```bash
+RUST_LOG=debug RUST_BACKTRACE=1 ./target/release/node-template -lruntime=debug --dev
+```
-If you want to see the multi-node consensus algorithm in action locally, then you can create a local testnet with two validator nodes for Alice and Bob, who are the initial authorities of the genesis chain that have been endowed with testnet units.
+### Multi-Node Local Testnet
-Optionally, give each node a name and expose them so they are listed on the Polkadot [telemetry site](https://telemetry.polkadot.io/#/Local%20Testnet).
+To see the multi-node consensus algorithm in action, run a local testnet with two validator nodes,
+Alice and Bob, that have been [configured](./node/src/chain_spec.rs) as the initial
+authorities of the `local` testnet chain and endowed with testnet units.
-You'll need two terminal windows open.
+Note: this will require two terminal sessions (one for each node).
-We'll start Alice's substrate node first on default TCP port 30333 with her chain database stored locally at `/tmp/alice`. The bootnode ID of her node is `QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR`, which is generated from the `--node-key` value that we specify below:
+Start Alice's node first. The command below uses the default TCP port (30333) and specifies
+`/tmp/alice` as the chain database location. Alice's node ID will be
+`12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp` (legacy representation:
+`QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR`); this is determined by the `node-key`.
```bash
cargo run -- \
@@ -60,17 +75,133 @@ cargo run -- \
--validator
```
-In the second terminal, we'll start Bob's substrate node on a different TCP port of 30334, and with his chain database stored locally at `/tmp/bob`. We'll specify a value for the `--bootnodes` option that will connect his node to Alice's bootnode ID on TCP port 30333:
+In another terminal, use the following command to start Bob's node on a different TCP port (30334)
+and with a chain database location of `/tmp/bob`. The `--bootnodes` option will connect his node to
+Alice's on TCP port 30333:
```bash
cargo run -- \
--base-path /tmp/bob \
- --bootnodes /ip4/127.0.0.1/tcp/30333/p2p/QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR \
+ --bootnodes /ip4/127.0.0.1/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp \
--chain=local \
--bob \
--port 30334 \
+ --ws-port 9945 \
--telemetry-url 'ws://telemetry.polkadot.io:1024 0' \
--validator
```
-Additional CLI usage options are available and may be shown by running `cargo run -- --help`.
+Execute `cargo run -- --help` to learn more about the template node's CLI options.
+
+## Template Structure
+
+A Substrate project such as this consists of a number of components that are spread across a few
+directories.
+
+### Node
+
+A blockchain node is an application that allows users to participate in a blockchain network.
+Substrate-based blockchain nodes expose a number of capabilities:
+
+- Networking: Substrate nodes use the [`libp2p`](https://libp2p.io/) networking stack to allow the
+ nodes in the network to communicate with one another.
+- Consensus: Blockchains must have a way to come to
+ [consensus](https://substrate.dev/docs/en/knowledgebase/advanced/consensus) on the state of the
+ network. Substrate makes it possible to supply custom consensus engines and also ships with
+ several consensus mechanisms that have been built on top of
+ [Web3 Foundation research](https://research.web3.foundation/en/latest/polkadot/NPoS/index.html).
+- RPC Server: A remote procedure call (RPC) server is used to interact with Substrate nodes.
+
+There are several files in the `node` directory - take special note of the following:
+
+- [`chain_spec.rs`](./node/src/chain_spec.rs): A
+ [chain specification](https://substrate.dev/docs/en/knowledgebase/integrate/chain-spec) is a
+ source code file that defines a Substrate chain's initial (genesis) state. Chain specifications
+ are useful for development and testing, and critical when architecting the launch of a
+ production chain. Take note of the `development_config` and `testnet_genesis` functions, which
+ are used to define the genesis state for the local development chain configuration. These
+ functions identify some
+ [well-known accounts](https://substrate.dev/docs/en/knowledgebase/integrate/subkey#well-known-keys)
+ and use them to configure the blockchain's initial state.
+- [`service.rs`](./node/src/service.rs): This file defines the node implementation. Take note of
+ the libraries that this file imports and the names of the functions it invokes. In particular,
+ there are references to consensus-related topics, such as the
+ [longest chain rule](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#longest-chain-rule),
+ the [Aura](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#aura) block authoring
+ mechanism and the
+ [GRANDPA](https://substrate.dev/docs/en/knowledgebase/advanced/consensus#grandpa) finality
+ gadget.
+
+After the node has been [built](#build), refer to the embedded documentation to learn more about the
+capabilities and configuration parameters that it exposes:
+
+```shell
+./target/release/node-template --help
+```
+
+### Runtime
+
+In Substrate, the terms
+"[runtime](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#runtime)" and
+"[state transition function](https://substrate.dev/docs/en/knowledgebase/getting-started/glossary#stf-state-transition-function)"
+are analogous - they refer to the core logic of the blockchain that is responsible for validating
+blocks and executing the state changes they define. The Substrate project in this repository uses
+the [FRAME](https://substrate.dev/docs/en/knowledgebase/runtime/frame) framework to construct a
+blockchain runtime. FRAME allows runtime developers to declare domain-specific logic in modules
+called "pallets". At the heart of FRAME is a helpful
+[macro language](https://substrate.dev/docs/en/knowledgebase/runtime/macros) that makes it easy to
+create pallets and flexibly compose them to create blockchains that can address
+[a variety of needs](https://www.substrate.io/substrate-users/).
+
+Review the [FRAME runtime implementation](./runtime/src/lib.rs) included in this template and note
+the following:
+
+- This file configures several pallets to include in the runtime. Each pallet configuration is
+ defined by a code block that begins with `impl $PALLET_NAME::Config for Runtime`.
+- The pallets are composed into a single runtime by way of the
+ [`construct_runtime!`](https://crates.parity.io/frame_support/macro.construct_runtime.html)
+ macro, which is part of the core
+ [FRAME Support](https://substrate.dev/docs/en/knowledgebase/runtime/frame#support-library)
+ library.
+
+### Pallets
+
+The runtime in this project is constructed using many FRAME pallets that ship with the
+[core Substrate repository](https://github.com/paritytech/substrate/tree/master/frame) and a
+template pallet that is [defined in the `pallets`](./pallets/template/src/lib.rs) directory.
+
+A FRAME pallet is compromised of a number of blockchain primitives:
+
+- Storage: FRAME defines a rich set of powerful
+ [storage abstractions](https://substrate.dev/docs/en/knowledgebase/runtime/storage) that makes
+ it easy to use Substrate's efficient key-value database to manage the evolving state of a
+ blockchain.
+- Dispatchables: FRAME pallets define special types of functions that can be invoked (dispatched)
+ from outside of the runtime in order to update its state.
+- Events: Substrate uses [events](https://substrate.dev/docs/en/knowledgebase/runtime/events) to
+ notify users of important changes in the runtime.
+- Errors: When a dispatchable fails, it returns an error.
+- Config: The `Config` configuration interface is used to define the types and parameters upon
+ which a FRAME pallet depends.
+
+## Generate a Custom Node Template
+
+Generate a Substrate node template based on a particular commit by running the following commands:
+
+```bash
+# Clone from the main Substrate repo
+git clone https://github.com/paritytech/substrate.git
+cd substrate
+
+# Switch to the branch or commit to base the template on
+git checkout