difftreelog
Initial node-template
in: master
17 files changed
.gitignorediffbeforeafterboth--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+**/target/
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+.DS_Store
\ No newline at end of file
substrate-node-rename.shdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-rename.sh
@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+name=$1
+shift
+author=$1
+shift
+
+if [[ "$name" == "" || "$name" == "-"* ]]
+then
+ echo "Usage: substrate-node-rename <NAME> <AUTHOR>"
+ exit 1
+fi
+if [[ "$author" == "" || "$author" == "-"* ]]
+then
+ echo "Usage: substrate-node-rename <NAME> <AUTHOR>"
+ exit 1
+fi
+
+lname="$(echo $name | tr '[:upper:]' '[:lower:]')"
+dirname="${lname// /-}"
+
+bold=$(tput bold)
+normal=$(tput sgr0)
+
+if [ -d "$dirname" ]; then
+ echo "Directory '$name' already exists!"
+ exit 1
+fi
+
+echo "${bold}Moving project folder...${normal}"
+
+git mv substrate-node-template $dirname
+
+pushd $dirname >/dev/null
+
+echo "${bold}Customizing project...${normal}"
+function replace {
+ find_this="$1"
+ shift
+ replace_with="$1"
+ shift
+ IFS=$'\n'
+ TEMP=$(mktemp -d "${TMPDIR:-/tmp}/.XXXXXXXXXXXX")
+ rmdir $TEMP
+ for item in `find . -not -path '*/\.*' -type f \( -name "*.rs" -o -name "*.md" -o -name "build.sh" -o -name "Cargo.toml" -o -name "Cargo.lock" \)`
+ do
+ sed "s/$find_this/$replace_with/g" "$item" > $TEMP
+ cat $TEMP > "$item"
+ done
+ rm -f $TEMP
+}
+
+replace "Template Node" "${name}"
+replace node-template "${lname//[_ ]/-}"
+replace node_template "${lname//[- ]/_}"
+replace Anonymous "$author"
+
+echo "Rename Complete"
+
+popd >/dev/null
substrate-node-template.tar.gzdiffbeforeafterbothbinary blob — no preview
substrate-node-template/Cargo.lockdiffbeforeafterbothno changes
substrate-node-template/Cargo.tomldiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/Cargo.toml
@@ -0,0 +1,103 @@
+[build-dependencies]
+vergen = '3'
+[profile.release]
+panic = 'unwind'
+
+[workspace]
+members = ['runtime']
+
+[dependencies]
+derive_more = '0.14.0'
+exit-future = '0.1'
+futures = '0.1'
+log = '0.4'
+parking_lot = '0.9.0'
+tokio = '0.1'
+trie-root = '0.15.2'
+
+[dependencies.babe]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-consensus-babe'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.babe-primitives]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-consensus-babe-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.basic-authorship]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-basic-authorship'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.codec]
+package = 'parity-scale-codec'
+version = '1.0.0'
+
+[dependencies.ctrlc]
+features = ['termination']
+version = '3.0'
+
+[dependencies.grandpa]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-finality-grandpa'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.grandpa-primitives]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-finality-grandpa-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.inherents]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-inherents'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.network]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-network'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.node-template-runtime]
+path = 'runtime'
+
+[dependencies.primitives]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.sr-io]
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.substrate-cli]
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.substrate-client]
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.substrate-executor]
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.substrate-service]
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.transaction-pool]
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-transaction-pool'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[package]
+authors = ['Anonymous']
+build = 'build.rs'
+edition = '2018'
+name = 'node-template'
+version = '2.0.0'
+
+[[bin]]
+name = 'node-template'
+path = 'src/main.rs'
substrate-node-template/LICENSEdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/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>
substrate-node-template/README.mddiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/README.md
@@ -0,0 +1,70 @@
+# Substrate Node Template
+
+A new SRML-based Substrate node, ready for hacking.
+
+## Build
+
+Install Rust:
+
+```bash
+curl https://sh.rustup.rs -sSf | sh
+```
+
+Install required tools:
+
+```bash
+./scripts/init.sh
+```
+
+Build Wasm and native code:
+
+```bash
+cargo build
+```
+
+## Run
+
+### Single node development chain
+
+You can start a development chain with:
+
+```bash
+cargo run -- --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`.
+
+### Multi-node local testnet
+
+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.
+
+Optionally, give each node a name and expose them so they are listed on the Polkadot [telemetry site](https://telemetry.polkadot.io/#/Local%20Testnet).
+
+You'll need two terminal windows open.
+
+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:
+
+```bash
+cargo run -- \
+ --base-path /tmp/alice \
+ --chain=local \
+ --alice \
+ --node-key 0000000000000000000000000000000000000000000000000000000000000001 \
+ --telemetry-url ws://telemetry.polkadot.io:1024 \
+ --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:
+
+```bash
+cargo run -- \
+ --base-path /tmp/bob \
+ --bootnodes /ip4/127.0.0.1/tcp/30333/p2p/QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR \
+ --chain=local \
+ --bob \
+ --port 30334 \
+ --telemetry-url ws://telemetry.polkadot.io:1024 \
+ --validator
+```
+
+Additional CLI usage options are available and may be shown by running `cargo run -- --help`.
substrate-node-template/build.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/build.rs
@@ -0,0 +1,24 @@
+use std::{env, path::PathBuf};
+
+use vergen::{ConstantsFlags, generate_cargo_keys};
+
+const ERROR_MSG: &str = "Failed to generate metadata files";
+
+fn main() {
+ generate_cargo_keys(ConstantsFlags::SHA_SHORT).expect(ERROR_MSG);
+
+ let mut manifest_dir = PathBuf::from(
+ env::var("CARGO_MANIFEST_DIR").expect("`CARGO_MANIFEST_DIR` is always set by cargo.")
+ );
+
+ while manifest_dir.parent().is_some() {
+ if manifest_dir.join(".git/HEAD").exists() {
+ println!("cargo:rerun-if-changed={}", manifest_dir.join(".git/HEAD").display());
+ return
+ }
+
+ manifest_dir.pop();
+ }
+
+ println!("cargo:warning=Could not find `.git/HEAD` from manifest dir!");
+}
substrate-node-template/runtime/Cargo.tomldiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/runtime/Cargo.toml
@@ -0,0 +1,155 @@
+[package]
+authors = ['Anonymous']
+edition = '2018'
+name = 'node-template-runtime'
+version = '2.0.0'
+[dependencies.babe]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-babe'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.babe-primitives]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-consensus-babe-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.balances]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-balances'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.client]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-client'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.codec]
+default-features = false
+features = ['derive']
+package = 'parity-scale-codec'
+version = '1.0.0'
+
+[dependencies.executive]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-executive'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.grandpa]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-grandpa'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.indices]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-indices'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.offchain-primitives]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-offchain-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.primitives]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'substrate-primitives'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.rstd]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'sr-std'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.runtime-io]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'sr-io'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.safe-mix]
+default-features = false
+version = '1.0'
+
+[dependencies.serde]
+features = ['derive']
+optional = true
+version = '1.0'
+
+[dependencies.sr-primitives]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.substrate-session]
+default-features = false
+git = 'https://github.com/paritytech/substrate.git'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.sudo]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-sudo'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.support]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-support'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.system]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-system'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.timestamp]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'srml-timestamp'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+
+[dependencies.version]
+default_features = false
+git = 'https://github.com/paritytech/substrate.git'
+package = 'sr-version'
+rev = '3ba0f2a2dbd37c31851a0ff1c1c0c47aa940de90'
+[build-dependencies.wasm-builder-runner]
+package = 'substrate-wasm-builder-runner'
+version = '1.0.2'
+
+[features]
+default = ['std']
+no_std = []
+std = [
+ 'codec/std',
+ 'client/std',
+ 'rstd/std',
+ 'runtime-io/std',
+ 'support/std',
+ 'balances/std',
+ 'babe/std',
+ 'babe-primitives/std',
+ 'executive/std',
+ 'indices/std',
+ 'grandpa/std',
+ 'primitives/std',
+ 'sr-primitives/std',
+ 'system/std',
+ 'timestamp/std',
+ 'sudo/std',
+ 'version/std',
+ 'serde',
+ 'safe-mix/std',
+ 'offchain-primitives/std',
+ 'substrate-session/std',
+]
substrate-node-template/runtime/build.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/runtime/build.rs
@@ -0,0 +1,27 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate. If not, see <http://www.gnu.org/licenses/>.
+
+use wasm_builder_runner::{build_current_project_with_rustflags, WasmBuilderSource};
+
+fn main() {
+ build_current_project_with_rustflags(
+ "wasm_binary.rs",
+ WasmBuilderSource::Crates("1.0.5"),
+ // This instructs LLD to export __heap_base as a global variable, which is used by the
+ // external memory allocator.
+ "-Clink-arg=--export=__heap_base",
+ );
+}
substrate-node-template/runtime/src/lib.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/runtime/src/lib.rs
@@ -0,0 +1,409 @@
+//! The Substrate Node Template runtime. This can be compiled with `#[no_std]`, ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
+#![recursion_limit="256"]
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+use rstd::prelude::*;
+use primitives::{OpaqueMetadata, crypto::key_types};
+use sr_primitives::{
+ ApplyResult, transaction_validity::TransactionValidity, generic, create_runtime_str,
+ impl_opaque_keys, AnySignature
+};
+use sr_primitives::traits::{NumberFor, BlakeTwo256, Block as BlockT, DigestFor, StaticLookup, Verify, ConvertInto};
+use sr_primitives::weights::Weight;
+use babe::{AuthorityId as BabeId};
+use grandpa::{AuthorityId as GrandpaId, AuthorityWeight as GrandpaWeight};
+use grandpa::fg_primitives::{self, ScheduledChange};
+use client::{
+ block_builder::api::{CheckInherentsResult, InherentData, self as block_builder_api},
+ runtime_api as client_api, impl_runtime_apis
+};
+use version::RuntimeVersion;
+#[cfg(feature = "std")]
+use version::NativeVersion;
+
+// A few exports that help ease life for downstream crates.
+#[cfg(any(feature = "std", test))]
+pub use sr_primitives::BuildStorage;
+pub use timestamp::Call as TimestampCall;
+pub use balances::Call as BalancesCall;
+pub use sr_primitives::{Permill, Perbill};
+pub use support::{StorageValue, construct_runtime, parameter_types};
+
+/// An index to a block.
+pub type BlockNumber = u32;
+
+/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
+pub type Signature = AnySignature;
+
+/// Some way of identifying an account on the chain. We intentionally make it equivalent
+/// to the public key of our transaction signing scheme.
+pub type AccountId = <Signature as Verify>::Signer;
+
+/// The type for looking up accounts. We don't expect more than 4 billion of them, but you
+/// never know...
+pub type AccountIndex = u32;
+
+/// Balance of an account.
+pub type Balance = u128;
+
+/// Index of a transaction in the chain.
+pub type Index = u32;
+
+/// A hash of some data used by the chain.
+pub type Hash = primitives::H256;
+
+/// Digest item type.
+pub type DigestItem = generic::DigestItem<Hash>;
+
+/// Used for the module template in `./template.rs`
+mod template;
+
+/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
+/// the specifics of the runtime. They can then be made to be agnostic over specific formats
+/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
+/// to even the core datastructures.
+pub mod opaque {
+ use super::*;
+
+ pub use sr_primitives::OpaqueExtrinsic as UncheckedExtrinsic;
+
+ /// Opaque block header type.
+ pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+ /// Opaque block type.
+ pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+ /// Opaque block identifier type.
+ pub type BlockId = generic::BlockId<Block>;
+
+ pub type SessionHandlers = (Grandpa, Babe);
+
+ impl_opaque_keys! {
+ pub struct SessionKeys {
+ #[id(key_types::GRANDPA)]
+ pub grandpa: GrandpaId,
+ #[id(key_types::BABE)]
+ pub babe: BabeId,
+ }
+ }
+}
+
+/// This runtime version.
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+ spec_name: create_runtime_str!("node-template"),
+ impl_name: create_runtime_str!("node-template"),
+ authoring_version: 3,
+ spec_version: 4,
+ impl_version: 4,
+ apis: RUNTIME_API_VERSIONS,
+};
+
+/// Constants for Babe.
+
+/// Since BABE is probabilistic this is the average expected block time that
+/// we are targetting. Blocks will be produced at a minimum duration defined
+/// by `SLOT_DURATION`, but some slots will not be allocated to any
+/// authority and hence no block will be produced. We expect to have this
+/// block time on average following the defined slot duration and the value
+/// of `c` configured for BABE (where `1 - c` represents the probability of
+/// a slot being empty).
+/// This value is only used indirectly to define the unit constants below
+/// that are expressed in blocks. The rest of the code should use
+/// `SLOT_DURATION` instead (like the timestamp module for calculating the
+/// minimum period).
+/// <https://research.web3.foundation/en/latest/polkadot/BABE/Babe/#6-practical-results>
+pub const MILLISECS_PER_BLOCK: u64 = 6000;
+
+pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
+
+pub const EPOCH_DURATION_IN_BLOCKS: u32 = 10 * MINUTES;
+
+// These time units are defined in number of blocks.
+pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
+pub const HOURS: BlockNumber = MINUTES * 60;
+pub const DAYS: BlockNumber = HOURS * 24;
+
+// 1 in 4 blocks (on average, not counting collisions) will be primary babe blocks.
+pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4);
+
+/// The version infromation 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(),
+ }
+}
+
+parameter_types! {
+ pub const BlockHashCount: BlockNumber = 250;
+ pub const MaximumBlockWeight: Weight = 1_000_000;
+ pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
+ pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;
+ pub const Version: RuntimeVersion = VERSION;
+}
+
+impl system::Trait for Runtime {
+ /// The identifier used to distinguish between accounts.
+ type AccountId = AccountId;
+ /// The aggregated dispatch type that is available for extrinsics.
+ type Call = Call;
+ /// The lookup mechanism to get account ID from whatever is passed in dispatchers.
+ type Lookup = Indices;
+ /// The index type for storing how many extrinsics an account has signed.
+ type Index = Index;
+ /// The index type for blocks.
+ type BlockNumber = BlockNumber;
+ /// The type for hashing blocks and tries.
+ type Hash = Hash;
+ /// The hashing algorithm used.
+ type Hashing = BlakeTwo256;
+ /// The header type.
+ type Header = generic::Header<BlockNumber, BlakeTwo256>;
+ /// The ubiquitous event type.
+ type Event = Event;
+ /// Update weight (to fee) multiplier per-block.
+ type WeightMultiplierUpdate = ();
+ /// The ubiquitous origin type.
+ type Origin = Origin;
+ /// Maximum number of block number to block hash mappings to keep (oldest pruned first).
+ type BlockHashCount = BlockHashCount;
+ /// Maximum weight of each block. With a default weight system of 1byte == 1weight, 4mb is ok.
+ type MaximumBlockWeight = MaximumBlockWeight;
+ /// Maximum size of all encoded transactions (in bytes) that are allowed in one block.
+ type MaximumBlockLength = MaximumBlockLength;
+ /// Portion of the block weight that is available to all normal transactions.
+ type AvailableBlockRatio = AvailableBlockRatio;
+ type Version = Version;
+}
+
+parameter_types! {
+ pub const EpochDuration: u64 = EPOCH_DURATION_IN_BLOCKS as u64;
+ pub const ExpectedBlockTime: u64 = MILLISECS_PER_BLOCK;
+}
+
+impl babe::Trait for Runtime {
+ type EpochDuration = EpochDuration;
+ type ExpectedBlockTime = ExpectedBlockTime;
+}
+
+impl grandpa::Trait for Runtime {
+ type Event = Event;
+}
+
+impl indices::Trait for Runtime {
+ /// The type for recording indexing into the account enumeration. If this ever overflows, there
+ /// will be problems!
+ type AccountIndex = u32;
+ /// Use the standard means of resolving an index hint from an id.
+ type ResolveHint = indices::SimpleResolveHint<Self::AccountId, Self::AccountIndex>;
+ /// Determine whether an account is dead.
+ type IsDeadAccount = Balances;
+ /// The ubiquitous event type.
+ type Event = Event;
+}
+
+parameter_types! {
+ pub const MinimumPeriod: u64 = 5000;
+}
+
+impl timestamp::Trait for Runtime {
+ /// A timestamp: milliseconds since the unix epoch.
+ type Moment = u64;
+ type OnTimestampSet = Babe;
+ type MinimumPeriod = MinimumPeriod;
+}
+
+parameter_types! {
+ pub const ExistentialDeposit: u128 = 500;
+ pub const TransferFee: u128 = 0;
+ pub const CreationFee: u128 = 0;
+ pub const TransactionBaseFee: u128 = 0;
+ pub const TransactionByteFee: u128 = 1;
+}
+
+impl balances::Trait for Runtime {
+ /// The type for recording an account's balance.
+ type Balance = Balance;
+ /// What to do if an account's free balance gets zeroed.
+ type OnFreeBalanceZero = ();
+ /// What to do if a new account is created.
+ type OnNewAccount = Indices;
+ /// The ubiquitous event type.
+ type Event = Event;
+
+ type TransactionPayment = ();
+ type DustRemoval = ();
+ type TransferPayment = ();
+ type ExistentialDeposit = ExistentialDeposit;
+ type TransferFee = TransferFee;
+ type CreationFee = CreationFee;
+ type TransactionBaseFee = TransactionBaseFee;
+ type TransactionByteFee = TransactionByteFee;
+ type WeightToFee = ConvertInto;
+}
+
+impl sudo::Trait for Runtime {
+ type Event = Event;
+ type Proposal = Call;
+}
+
+/// Used for the module template in `./template.rs`
+impl template::Trait for Runtime {
+ type Event = Event;
+}
+
+construct_runtime!(
+ pub enum Runtime where
+ Block = Block,
+ NodeBlock = opaque::Block,
+ UncheckedExtrinsic = UncheckedExtrinsic
+ {
+ System: system::{Module, Call, Storage, Config, Event},
+ Timestamp: timestamp::{Module, Call, Storage, Inherent},
+ Babe: babe::{Module, Call, Storage, Config, Inherent(Timestamp)},
+ Grandpa: grandpa::{Module, Call, Storage, Config, Event},
+ Indices: indices::{default, Config<T>},
+ Balances: balances,
+ Sudo: sudo,
+ // Used for the module template in `./template.rs`
+ TemplateModule: template::{Module, Call, Storage, Event<T>},
+ }
+);
+
+/// The address format for describing accounts.
+pub type Address = <Indices as StaticLookup>::Source;
+/// Block header type as expected by this runtime.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+/// Block type as expected by this runtime.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// A Block signed with a Justification
+pub type SignedBlock = generic::SignedBlock<Block>;
+/// BlockId type as expected by this runtime.
+pub type BlockId = generic::BlockId<Block>;
+/// The SignedExtension to the basic transaction logic.
+pub type SignedExtra = (
+ system::CheckVersion<Runtime>,
+ system::CheckGenesis<Runtime>,
+ system::CheckEra<Runtime>,
+ system::CheckNonce<Runtime>,
+ system::CheckWeight<Runtime>,
+ balances::TakeFees<Runtime>
+);
+/// Unchecked extrinsic type as expected by this runtime.
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
+/// Extrinsic type that has already been checked.
+pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
+/// Executive: handles dispatch to the various modules.
+pub type Executive = executive::Executive<Runtime, Block, system::ChainContext<Runtime>, Runtime, AllModules>;
+
+impl_runtime_apis! {
+ impl client_api::Core<Block> for Runtime {
+ fn version() -> RuntimeVersion {
+ VERSION
+ }
+
+ fn execute_block(block: Block) {
+ Executive::execute_block(block)
+ }
+
+ fn initialize_block(header: &<Block as BlockT>::Header) {
+ Executive::initialize_block(header)
+ }
+ }
+
+ impl client_api::Metadata<Block> for Runtime {
+ fn metadata() -> OpaqueMetadata {
+ Runtime::metadata().into()
+ }
+ }
+
+ impl block_builder_api::BlockBuilder<Block> for Runtime {
+ fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyResult {
+ Executive::apply_extrinsic(extrinsic)
+ }
+
+ fn finalize_block() -> <Block as BlockT>::Header {
+ Executive::finalize_block()
+ }
+
+ fn inherent_extrinsics(data: InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+ data.create_extrinsics()
+ }
+
+ fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult {
+ data.check_extrinsics(&block)
+ }
+
+ fn random_seed() -> <Block as BlockT>::Hash {
+ System::random_seed()
+ }
+ }
+
+ impl client_api::TaggedTransactionQueue<Block> for Runtime {
+ fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {
+ Executive::validate_transaction(tx)
+ }
+ }
+
+ impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
+ fn offchain_worker(number: NumberFor<Block>) {
+ Executive::offchain_worker(number)
+ }
+ }
+
+ impl fg_primitives::GrandpaApi<Block> for Runtime {
+ fn grandpa_pending_change(digest: &DigestFor<Block>)
+ -> Option<ScheduledChange<NumberFor<Block>>>
+ {
+ Grandpa::pending_change(digest)
+ }
+
+ fn grandpa_forced_change(digest: &DigestFor<Block>)
+ -> Option<(NumberFor<Block>, ScheduledChange<NumberFor<Block>>)>
+ {
+ Grandpa::forced_change(digest)
+ }
+
+ fn grandpa_authorities() -> Vec<(GrandpaId, GrandpaWeight)> {
+ Grandpa::grandpa_authorities()
+ }
+ }
+
+ impl babe_primitives::BabeApi<Block> for Runtime {
+ fn startup_data() -> babe_primitives::BabeConfiguration {
+ // The choice of `c` parameter (where `1 - c` represents the
+ // probability of a slot being empty), is done in accordance to the
+ // slot duration and expected target block time, for safely
+ // resisting network delays of maximum two seconds.
+ // <https://research.web3.foundation/en/latest/polkadot/BABE/Babe/#6-practical-results>
+ babe_primitives::BabeConfiguration {
+ median_required_blocks: 1000,
+ slot_duration: Babe::slot_duration(),
+ c: PRIMARY_PROBABILITY,
+ }
+ }
+
+ fn epoch() -> babe_primitives::Epoch {
+ babe_primitives::Epoch {
+ start_slot: Babe::epoch_start_slot(),
+ authorities: Babe::authorities(),
+ epoch_index: Babe::epoch_index(),
+ randomness: Babe::randomness(),
+ duration: EpochDuration::get(),
+ secondary_slots: Babe::secondary_slots().0,
+ }
+ }
+ }
+
+ impl substrate_session::SessionKeys<Block> for Runtime {
+ fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
+ let seed = seed.as_ref().map(|s| rstd::str::from_utf8(&s).expect("Seed is an utf8 string"));
+ opaque::SessionKeys::generate(seed)
+ }
+ }
+}
substrate-node-template/runtime/src/template.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/runtime/src/template.rs
@@ -0,0 +1,133 @@
+/// A runtime module template with necessary imports
+
+/// Feel free to remove or edit this file as needed.
+/// If you change the name of this file, make sure to update its references in runtime/src/lib.rs
+/// If you remove this file, you can remove those references
+
+
+/// For more guidance on Substrate modules, see the example module
+/// https://github.com/paritytech/substrate/blob/master/srml/example/src/lib.rs
+
+use support::{decl_module, decl_storage, decl_event, StorageValue, dispatch::Result};
+use system::ensure_signed;
+
+/// The module's configuration trait.
+pub trait Trait: system::Trait {
+ // TODO: Add other types and constants required configure this module.
+
+ /// The overarching event type.
+ type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
+}
+
+// This module's storage items.
+decl_storage! {
+ trait Store for Module<T: Trait> as TemplateModule {
+ // Just a dummy storage item.
+ // Here we are declaring a StorageValue, `Something` as a Option<u32>
+ // `get(something)` is the default getter which returns either the stored `u32` or `None` if nothing stored
+ Something get(something): Option<u32>;
+ }
+}
+
+// The module's dispatchable functions.
+decl_module! {
+ /// The module declaration.
+ pub struct Module<T: Trait> for enum Call where origin: T::Origin {
+ // Initializing events
+ // this is needed only if you are using events in your module
+ fn deposit_event() = default;
+
+ // Just a dummy entry point.
+ // function that can be called by the external world as an extrinsics call
+ // takes a parameter of the type `AccountId`, stores it and emits an event
+ pub fn do_something(origin, something: u32) -> Result {
+ // TODO: You only need this if you want to check it was signed.
+ let who = ensure_signed(origin)?;
+
+ // TODO: Code to execute when something calls this.
+ // For example: the following line stores the passed in u32 in the storage
+ Something::put(something);
+
+ // here we are raising the Something event
+ Self::deposit_event(RawEvent::SomethingStored(something, who));
+ Ok(())
+ }
+ }
+}
+
+decl_event!(
+ pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {
+ // Just a dummy event.
+ // Event `Something` is declared with a parameter of the type `u32` and `AccountId`
+ // To emit this event, we call the deposit funtion, from our runtime funtions
+ SomethingStored(u32, AccountId),
+ }
+);
+
+/// tests for this module
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ use runtime_io::with_externalities;
+ use primitives::{H256, Blake2Hasher};
+ use support::{impl_outer_origin, assert_ok, parameter_types};
+ use sr_primitives::{traits::{BlakeTwo256, IdentityLookup}, testing::Header};
+ use sr_primitives::weights::Weight;
+ use sr_primitives::Perbill;
+
+ impl_outer_origin! {
+ pub enum Origin for Test {}
+ }
+
+ // For testing the module, we construct most of a mock runtime. This means
+ // first constructing a configuration type (`Test`) which `impl`s each of the
+ // configuration traits of modules we want to use.
+ #[derive(Clone, Eq, PartialEq)]
+ pub struct Test;
+ parameter_types! {
+ pub const BlockHashCount: u64 = 250;
+ pub const MaximumBlockWeight: Weight = 1024;
+ pub const MaximumBlockLength: u32 = 2 * 1024;
+ pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
+ }
+ impl system::Trait for Test {
+ type Origin = Origin;
+ type Call = ();
+ type Index = u64;
+ type BlockNumber = u64;
+ type Hash = H256;
+ type Hashing = BlakeTwo256;
+ type AccountId = u64;
+ type Lookup = IdentityLookup<Self::AccountId>;
+ type Header = Header;
+ type WeightMultiplierUpdate = ();
+ type Event = ();
+ type BlockHashCount = BlockHashCount;
+ type MaximumBlockWeight = MaximumBlockWeight;
+ type MaximumBlockLength = MaximumBlockLength;
+ type AvailableBlockRatio = AvailableBlockRatio;
+ type Version = ();
+ }
+ impl Trait for Test {
+ type Event = ();
+ }
+ type TemplateModule = Module<Test>;
+
+ // This function basically just builds a genesis storage key/value store according to
+ // our desired mockup.
+ fn new_test_ext() -> runtime_io::TestExternalities<Blake2Hasher> {
+ system::GenesisConfig::default().build_storage::<Test>().unwrap().into()
+ }
+
+ #[test]
+ fn it_works_for_default_value() {
+ with_externalities(&mut new_test_ext(), || {
+ // Just a dummy test for the dummy funtion `do_something`
+ // calling the `do_something` function with a value 42
+ assert_ok!(TemplateModule::do_something(Origin::signed(1), 42));
+ // asserting that the stored value is equal to what we stored
+ assert_eq!(TemplateModule::something(), Some(42));
+ });
+ }
+}
substrate-node-template/scripts/init.shdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/scripts/init.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "*** Initializing WASM build environment"
+
+if [ -z $CI_PROJECT_NAME ] ; then
+ rustup update nightly
+ rustup update stable
+fi
+
+rustup target add wasm32-unknown-unknown --toolchain nightly
+
+# Install wasm-gc. It's useful for stripping slimming down wasm binaries.
+command -v wasm-gc || \
+ cargo +nightly install --git https://github.com/alexcrichton/wasm-gc --force
substrate-node-template/src/chain_spec.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/src/chain_spec.rs
@@ -0,0 +1,135 @@
+use primitives::{Pair, Public};
+use node_template_runtime::{
+ AccountId, BabeConfig, BalancesConfig, GenesisConfig, GrandpaConfig,
+ SudoConfig, IndicesConfig, SystemConfig, WASM_BINARY,
+};
+use babe_primitives::{AuthorityId as BabeId};
+use grandpa_primitives::{AuthorityId as GrandpaId};
+use substrate_service;
+
+// Note this is the URL for the telemetry server
+//const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/";
+
+/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type.
+pub type ChainSpec = substrate_service::ChainSpec<GenesisConfig>;
+
+/// The chain specification option. This is expected to come in from the CLI and
+/// is little more than one of a number of alternatives which can easily be converted
+/// from a string (`--chain=...`) into a `ChainSpec`.
+#[derive(Clone, Debug)]
+pub enum Alternative {
+ /// Whatever the current runtime is, with just Alice as an auth.
+ Development,
+ /// Whatever the current runtime is, with simple Alice/Bob auths.
+ LocalTestnet,
+}
+
+/// Helper function to generate a crypto pair from seed
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+ TPublic::Pair::from_string(&format!("//{}", seed), None)
+ .expect("static values are valid; qed")
+ .public()
+}
+
+/// Helper function to generate stash, controller and session key from seed
+pub fn get_authority_keys_from_seed(seed: &str) -> (AccountId, AccountId, GrandpaId, BabeId) {
+ (
+ get_from_seed::<AccountId>(&format!("{}//stash", seed)),
+ get_from_seed::<AccountId>(seed),
+ get_from_seed::<GrandpaId>(seed),
+ get_from_seed::<BabeId>(seed),
+ )
+}
+
+impl Alternative {
+ /// Get an actual chain config from one of the alternatives.
+ pub(crate) fn load(self) -> Result<ChainSpec, String> {
+ Ok(match self {
+ Alternative::Development => ChainSpec::from_genesis(
+ "Development",
+ "dev",
+ || testnet_genesis(vec![
+ get_authority_keys_from_seed("Alice"),
+ ],
+ get_from_seed::<AccountId>("Alice"),
+ vec![
+ get_from_seed::<AccountId>("Alice"),
+ get_from_seed::<AccountId>("Bob"),
+ get_from_seed::<AccountId>("Alice//stash"),
+ get_from_seed::<AccountId>("Bob//stash"),
+ ],
+ true),
+ vec![],
+ None,
+ None,
+ None,
+ None
+ ),
+ Alternative::LocalTestnet => ChainSpec::from_genesis(
+ "Local Testnet",
+ "local_testnet",
+ || testnet_genesis(vec![
+ get_authority_keys_from_seed("Alice"),
+ get_authority_keys_from_seed("Bob"),
+ ],
+ get_from_seed::<AccountId>("Alice"),
+ vec![
+ get_from_seed::<AccountId>("Alice"),
+ get_from_seed::<AccountId>("Bob"),
+ get_from_seed::<AccountId>("Charlie"),
+ get_from_seed::<AccountId>("Dave"),
+ get_from_seed::<AccountId>("Eve"),
+ get_from_seed::<AccountId>("Ferdie"),
+ get_from_seed::<AccountId>("Alice//stash"),
+ get_from_seed::<AccountId>("Bob//stash"),
+ get_from_seed::<AccountId>("Charlie//stash"),
+ get_from_seed::<AccountId>("Dave//stash"),
+ get_from_seed::<AccountId>("Eve//stash"),
+ get_from_seed::<AccountId>("Ferdie//stash"),
+ ],
+ true),
+ vec![],
+ None,
+ None,
+ None,
+ None
+ ),
+ })
+ }
+
+ pub(crate) fn from(s: &str) -> Option<Self> {
+ match s {
+ "dev" => Some(Alternative::Development),
+ "" | "local" => Some(Alternative::LocalTestnet),
+ _ => None,
+ }
+ }
+}
+
+fn testnet_genesis(initial_authorities: Vec<(AccountId, AccountId, GrandpaId, BabeId)>,
+ root_key: AccountId,
+ endowed_accounts: Vec<AccountId>,
+ _enable_println: bool) -> GenesisConfig {
+ GenesisConfig {
+ system: Some(SystemConfig {
+ code: WASM_BINARY.to_vec(),
+ changes_trie_config: Default::default(),
+ }),
+ indices: Some(IndicesConfig {
+ ids: endowed_accounts.clone(),
+ }),
+ balances: Some(BalancesConfig {
+ balances: endowed_accounts.iter().cloned().map(|k|(k, 1 << 60)).collect(),
+ vesting: vec![],
+ }),
+ sudo: Some(SudoConfig {
+ key: root_key,
+ }),
+ babe: Some(BabeConfig {
+ authorities: initial_authorities.iter().map(|x| (x.3.clone(), 1)).collect(),
+ }),
+ grandpa: Some(GrandpaConfig {
+ authorities: initial_authorities.iter().map(|x| (x.2.clone(), 1)).collect(),
+ }),
+ }
+}
substrate-node-template/src/cli.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/src/cli.rs
@@ -0,0 +1,112 @@
+use crate::service;
+use futures::{future, Future, sync::oneshot};
+use std::cell::RefCell;
+use tokio::runtime::Runtime;
+pub use substrate_cli::{VersionInfo, IntoExit, error};
+use substrate_cli::{informant, parse_and_prepare, ParseAndPrepare, NoCustom};
+use substrate_service::{AbstractService, Roles as ServiceRoles};
+use crate::chain_spec;
+use log::info;
+
+/// Parse command line arguments into service configuration.
+pub fn run<I, T, E>(args: I, exit: E, version: VersionInfo) -> error::Result<()> where
+ I: IntoIterator<Item = T>,
+ T: Into<std::ffi::OsString> + Clone,
+ E: IntoExit,
+{
+ match parse_and_prepare::<NoCustom, NoCustom, _>(&version, "substrate-node", args) {
+ ParseAndPrepare::Run(cmd) => cmd.run::<(), _, _, _, _>(load_spec, exit,
+ |exit, _cli_args, _custom_args, config| {
+ info!("{}", version.name);
+ info!(" version {}", config.full_version());
+ info!(" by {}, 2017, 2018", version.author);
+ info!("Chain specification: {}", config.chain_spec.name());
+ info!("Node name: {}", config.name);
+ info!("Roles: {:?}", config.roles);
+ let runtime = Runtime::new().map_err(|e| format!("{:?}", e))?;
+ match config.roles {
+ ServiceRoles::LIGHT => run_until_exit(
+ runtime,
+ service::new_light(config).map_err(|e| format!("{:?}", e))?,
+ exit
+ ),
+ _ => run_until_exit(
+ runtime,
+ service::new_full(config).map_err(|e| format!("{:?}", e))?,
+ exit
+ ),
+ }.map_err(|e| format!("{:?}", e))
+ }),
+ ParseAndPrepare::BuildSpec(cmd) => cmd.run(load_spec),
+ ParseAndPrepare::ExportBlocks(cmd) => cmd.run_with_builder::<(), _, _, _, _, _>(|config|
+ Ok(new_full_start!(config).0), load_spec, exit),
+ ParseAndPrepare::ImportBlocks(cmd) => cmd.run_with_builder::<(), _, _, _, _, _>(|config|
+ Ok(new_full_start!(config).0), load_spec, exit),
+ ParseAndPrepare::PurgeChain(cmd) => cmd.run(load_spec),
+ ParseAndPrepare::RevertChain(cmd) => cmd.run_with_builder::<(), _, _, _, _>(|config|
+ Ok(new_full_start!(config).0), load_spec),
+ ParseAndPrepare::CustomCommand(_) => Ok(())
+ }?;
+
+ Ok(())
+}
+
+fn load_spec(id: &str) -> Result<Option<chain_spec::ChainSpec>, String> {
+ Ok(match chain_spec::Alternative::from(id) {
+ Some(spec) => Some(spec.load()?),
+ None => None,
+ })
+}
+
+fn run_until_exit<T, E>(
+ mut runtime: Runtime,
+ service: T,
+ e: E,
+) -> error::Result<()>
+where
+ T: AbstractService,
+ E: IntoExit,
+{
+ let (exit_send, exit) = exit_future::signal();
+
+ let informant = informant::build(&service);
+ runtime.executor().spawn(exit.until(informant).map(|_| ()));
+
+ // we eagerly drop the service so that the internal exit future is fired,
+ // but we need to keep holding a reference to the global telemetry guard
+ let _telemetry = service.telemetry();
+
+ let service_res = {
+ let exit = e.into_exit().map_err(|_| error::Error::Other("Exit future failed.".into()));
+ let service = service.map_err(|err| error::Error::Service(err));
+ let select = service.select(exit).map(|_| ()).map_err(|(err, _)| err);
+ runtime.block_on(select)
+ };
+
+ exit_send.fire();
+
+ // TODO [andre]: timeout this future #1318
+ let _ = runtime.shutdown_on_idle().wait();
+
+ service_res
+}
+
+// handles ctrl-c
+pub struct Exit;
+impl IntoExit for Exit {
+ type Exit = future::MapErr<oneshot::Receiver<()>, fn(oneshot::Canceled) -> ()>;
+ fn into_exit(self) -> Self::Exit {
+ // can't use signal directly here because CtrlC takes only `Fn`.
+ let (exit_send, exit) = oneshot::channel();
+
+ let exit_send_cell = RefCell::new(Some(exit_send));
+ ctrlc::set_handler(move || {
+ let exit_send = exit_send_cell.try_borrow_mut().expect("signal handler not reentrant; qed").take();
+ if let Some(exit_send) = exit_send {
+ exit_send.send(()).expect("Error sending exit notification");
+ }
+ }).expect("Error setting Ctrl-C handler");
+
+ exit.map_err(drop)
+ }
+}
substrate-node-template/src/main.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/src/main.rs
@@ -0,0 +1,28 @@
+//! Substrate Node Template CLI library.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+mod chain_spec;
+#[macro_use]
+mod service;
+mod cli;
+
+pub use substrate_cli::{VersionInfo, IntoExit, error};
+
+fn main() {
+ let version = VersionInfo {
+ name: "Substrate Node",
+ commit: env!("VERGEN_SHA_SHORT"),
+ version: env!("CARGO_PKG_VERSION"),
+ executable_name: "node-template",
+ author: "Anonymous",
+ description: "Template Node",
+ support_url: "support.anonymous.an",
+ };
+
+ if let Err(e) = cli::run(::std::env::args(), cli::Exit, version) {
+ eprintln!("Fatal error: {}\n\n{:?}", e, e);
+ std::process::exit(1)
+ }
+}
substrate-node-template/src/service.rsdiffbeforeafterboth--- /dev/null
+++ b/substrate-node-template/src/service.rs
@@ -0,0 +1,230 @@
+//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+
+use std::sync::Arc;
+use std::time::Duration;
+use substrate_client::LongestChain;
+use babe::{import_queue, start_babe, Config};
+use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
+use futures::prelude::*;
+use node_template_runtime::{self, GenesisConfig, opaque::Block, RuntimeApi, WASM_BINARY};
+use substrate_service::{error::{Error as ServiceError}, AbstractService, Configuration, ServiceBuilder};
+use transaction_pool::{self, txpool::{Pool as TransactionPool}};
+use inherents::InherentDataProviders;
+use network::construct_simple_protocol;
+use substrate_executor::native_executor_instance;
+pub use substrate_executor::NativeExecutor;
+
+// Our native executor instance.
+native_executor_instance!(
+ pub Executor,
+ node_template_runtime::api::dispatch,
+ node_template_runtime::native_version
+);
+
+construct_simple_protocol! {
+ /// Demo protocol attachment for substrate.
+ pub struct NodeProtocol where Block = Block { }
+}
+
+/// Starts a `ServiceBuilder` for a full service.
+///
+/// Use this macro if you don't actually need the full service, but just the builder in order to
+/// be able to perform chain operations.
+macro_rules! new_full_start {
+ ($config:expr) => {{
+ let mut import_setup = None;
+ let inherent_data_providers = inherents::InherentDataProviders::new();
+ let mut tasks_to_spawn = None;
+
+ let builder = substrate_service::ServiceBuilder::new_full::<
+ node_template_runtime::opaque::Block, node_template_runtime::RuntimeApi, crate::service::Executor
+ >($config)?
+ .with_select_chain(|_config, client| {
+ #[allow(deprecated)]
+ Ok(substrate_client::LongestChain::new(client.backend().clone()))
+ })?
+ .with_transaction_pool(|config, client|
+ Ok(transaction_pool::txpool::Pool::new(config, transaction_pool::ChainApi::new(client)))
+ )?
+ .with_import_queue(|_config, client, mut select_chain, transaction_pool| {
+ let select_chain = select_chain.take()
+ .ok_or_else(|| substrate_service::Error::SelectChainRequired)?;
+ let (block_import, link_half) =
+ grandpa::block_import::<_, _, _, node_template_runtime::RuntimeApi, _, _>(
+ client.clone(), client.clone(), select_chain
+ )?;
+ let justification_import = block_import.clone();
+
+ let (import_queue, babe_link, babe_block_import, pruning_task) = babe::import_queue(
+ babe::Config::get_or_compute(&*client)?,
+ block_import,
+ Some(Box::new(justification_import)),
+ None,
+ client.clone(),
+ client,
+ inherent_data_providers.clone(),
+ Some(transaction_pool)
+ )?;
+
+ import_setup = Some((babe_block_import.clone(), link_half, babe_link));
+ tasks_to_spawn = Some(vec![Box::new(pruning_task)]);
+
+ Ok(import_queue)
+ })?;
+
+ (builder, import_setup, inherent_data_providers, tasks_to_spawn)
+ }}
+}
+
+/// Builds a new service for a full client.
+pub fn new_full<C: Send + Default + 'static>(config: Configuration<C, GenesisConfig>)
+ -> Result<impl AbstractService, ServiceError>
+{
+
+ let (builder, mut import_setup, inherent_data_providers, mut tasks_to_spawn) = new_full_start!(config);
+
+ let service = builder.with_network_protocol(|_| Ok(NodeProtocol::new()))?
+ .with_finality_proof_provider(|client|
+ Ok(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _)
+ )?
+ .build()?;
+
+ let (block_import, link_half, babe_link) =
+ import_setup.take()
+ .expect("Link Half and Block Import are present for Full Services or setup failed before. qed");
+
+ // spawn any futures that were created in the previous setup steps
+ if let Some(tasks) = tasks_to_spawn.take() {
+ for task in tasks {
+ service.spawn_task(
+ task.select(service.on_exit())
+ .map(|_| ())
+ .map_err(|_| ())
+ );
+ }
+ }
+
+ if service.config().roles.is_authority() {
+ let proposer = basic_authorship::ProposerFactory {
+ client: service.client(),
+ transaction_pool: service.transaction_pool(),
+ };
+
+ let client = service.client();
+ let select_chain = service.select_chain()
+ .ok_or(ServiceError::SelectChainRequired)?;
+
+ let babe_config = babe::BabeParams {
+ config: Config::get_or_compute(&*client)?,
+ keystore: service.keystore(),
+ client,
+ select_chain,
+ block_import,
+ env: proposer,
+ sync_oracle: service.network(),
+ inherent_data_providers: inherent_data_providers.clone(),
+ force_authoring: service.config().force_authoring,
+ time_source: babe_link,
+ };
+
+ let babe = start_babe(babe_config)?;
+ let select = babe.select(service.on_exit()).then(|_| Ok(()));
+
+ // the BABE authoring task is considered infallible, i.e. if it
+ // fails we take down the service with it.
+ service.spawn_essential_task(select);
+ }
+
+ let config = grandpa::Config {
+ // FIXME #1578 make this available through chainspec
+ gossip_duration: Duration::from_millis(333),
+ justification_period: 4096,
+ name: Some(service.config().name.clone()),
+ keystore: Some(service.keystore()),
+ };
+
+ match (service.config().roles.is_authority(), service.config().disable_grandpa) {
+ (false, false) => {
+ // start the lightweight GRANDPA observer
+ service.spawn_task(Box::new(grandpa::run_grandpa_observer(
+ config,
+ link_half,
+ service.network(),
+ service.on_exit(),
+ )?));
+ },
+ (true, false) => {
+ // start the full GRANDPA voter
+ let grandpa_config = grandpa::GrandpaParams {
+ config: config,
+ link: link_half,
+ network: service.network(),
+ inherent_data_providers: inherent_data_providers.clone(),
+ on_exit: service.on_exit(),
+ telemetry_on_connect: Some(service.telemetry_on_connect_stream()),
+ };
+
+ // the GRANDPA voter task is considered infallible, i.e.
+ // if it fails we take down the service with it.
+ service.spawn_essential_task(grandpa::run_grandpa_voter(grandpa_config)?);
+ },
+ (_, true) => {
+ grandpa::setup_disabled_grandpa(
+ service.client(),
+ &inherent_data_providers,
+ service.network(),
+ )?;
+ },
+ }
+
+ Ok(service)
+}
+
+/// Builds a new service for a light client.
+pub fn new_light<C: Send + Default + 'static>(config: Configuration<C, GenesisConfig>)
+ -> Result<impl AbstractService, ServiceError>
+{
+ let inherent_data_providers = InherentDataProviders::new();
+
+ ServiceBuilder::new_light::<Block, RuntimeApi, Executor>(config)?
+ .with_select_chain(|_config, client| {
+ #[allow(deprecated)]
+ Ok(LongestChain::new(client.backend().clone()))
+ })?
+ .with_transaction_pool(|config, client|
+ Ok(TransactionPool::new(config, transaction_pool::ChainApi::new(client)))
+ )?
+ .with_import_queue_and_fprb(|_config, client, _select_chain, transaction_pool| {
+ #[allow(deprecated)]
+ let fetch_checker = client.backend().blockchain().fetcher()
+ .upgrade()
+ .map(|fetcher| fetcher.checker().clone())
+ .ok_or_else(|| "Trying to start light import queue without active fetch checker")?;
+ let block_import = grandpa::light_block_import::<_, _, _, RuntimeApi, _>(
+ client.clone(), Arc::new(fetch_checker), client.clone()
+ )?;
+
+ let finality_proof_import = block_import.clone();
+ let finality_proof_request_builder =
+ finality_proof_import.create_finality_proof_request_builder();
+
+ // FIXME: pruning task isn't started since light client doesn't do `AuthoritySetup`.
+ let (import_queue, ..) = import_queue(
+ Config::get_or_compute(&*client)?,
+ block_import,
+ None,
+ Some(Box::new(finality_proof_import)),
+ client.clone(),
+ client,
+ inherent_data_providers.clone(),
+ Some(transaction_pool)
+ )?;
+
+ Ok((import_queue, finality_proof_request_builder))
+ })?
+ .with_network_protocol(|_| Ok(NodeProtocol::new()))?
+ .with_finality_proof_provider(|client|
+ Ok(Arc::new(GrandpaFinalityProofProvider::new(client.clone(), client)) as _)
+ )?
+ .build()
+}