Introduce substrate-demo

substrate/Cargo.lock

@@ -181,6 +181,76 @@ name = "crunchy"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[package]]
+name = "demo-cli"
+version = "0.1.0"
+dependencies = [
+ "clap 2.29.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "demo-executor 0.1.0",
+ "demo-primitives 0.1.0",
+ "demo-runtime 0.1.0",
+ "ed25519 0.1.0",
+ "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-client 0.1.0",
+ "substrate-codec 0.1.0",
+ "substrate-executor 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-rpc-servers 0.1.0",
+ "substrate-runtime-io 0.1.0",
+ "substrate-state-machine 0.1.0",
+ "triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "demo-executor"
+version = "0.1.0"
+dependencies = [
+ "demo-primitives 0.1.0",
+ "demo-runtime 0.1.0",
+ "ed25519 0.1.0",
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-executor 0.1.0",
+ "substrate-keyring 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-io 0.1.0",
+ "substrate-runtime-support 0.1.0",
+ "substrate-state-machine 0.1.0",
+ "triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "demo-primitives"
+version = "0.1.0"
+dependencies = [
+ "pretty_assertions 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-std 0.1.0",
+ "substrate-serializer 0.1.0",
+]
+
+[[package]]
+name = "demo-runtime"
+version = "0.1.0"
+dependencies = [
+ "demo-primitives 0.1.0",
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-keyring 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-io 0.1.0",
+ "substrate-runtime-std 0.1.0",
+ "substrate-runtime-support 0.1.0",
+]
+
 [[package]]
 name = "difference"
 version = "1.0.0"

substrate/Cargo.toml

@@ -38,9 +38,14 @@ members = [
 	"substrate/serializer",
 	"substrate/state-machine",
 	"substrate/test-runtime",
+	"demo/runtime",
+	"demo/primitives",
+	"demo/executor",
+	"demo/cli",
 ]
 exclude = [
 	"polkadot/runtime/wasm",
+	"demo/runtime/wasm",
 	"substrate/executor/wasm",
 	"substrate/pwasm-alloc",
 	"substrate/pwasm-libc",

substrate/demo/cli/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "demo-cli"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate Demo node implementation in Rust."
+
+[dependencies]
+clap = { version = "2.27", features = ["yaml"] }
+env_logger = "0.4"
+error-chain = "0.11"
+log = "0.3"
+hex-literal = "0.1"
+triehash = "0.1"
+ed25519 = { path = "../../substrate/ed25519" }
+substrate-client = { path = "../../substrate/client" }
+substrate-codec = { path = "../../substrate/codec" }
+substrate-runtime-io = { path = "../../substrate/runtime-io" }
+substrate-state-machine = { path = "../../substrate/state-machine" }
+substrate-executor = { path = "../../substrate/executor" }
+substrate-primitives = { path = "../../substrate/primitives" }
+substrate-rpc-servers = { path = "../../substrate/rpc-servers" }
+demo-primitives = { path = "../primitives" }
+demo-executor = { path = "../executor" }
+demo-runtime = { path = "../runtime" }

substrate/demo/cli/src/cli.yml

@@ -0,0 +1,12 @@
+name: substrate-demo
+author: "Parity Team <admin@parity.io>"
+about: Substrate Demo Node Rust Implementation
+args:
+  - log:
+      short: l
+      value_name: LOG_PATTERN
+      help: Sets a custom logging
+      takes_value: true
+subcommands:
+  - validator:
+      about: Run validator node

substrate/demo/cli/src/error.rs

@@ -0,0 +1,29 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Initialization errors.
+
+use client;
+
+error_chain! {
+	foreign_links {
+		Io(::std::io::Error) #[doc="IO error"];
+		Cli(::clap::Error) #[doc="CLI error"];
+	}
+	links {
+		Client(client::error::Error, client::error::ErrorKind) #[doc="Client error"];
+    }
+}

substrate/demo/cli/src/lib.rs

@@ -0,0 +1,127 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Substrate Demo CLI library.
+
+#![warn(missing_docs)]
+
+extern crate env_logger;
+extern crate ed25519;
+extern crate triehash;
+extern crate substrate_codec as codec;
+extern crate substrate_state_machine as state_machine;
+extern crate substrate_client as client;
+extern crate substrate_primitives as primitives;
+extern crate substrate_rpc_servers as rpc;
+extern crate demo_primitives;
+extern crate demo_executor;
+extern crate demo_runtime;
+
+#[macro_use]
+extern crate hex_literal;
+#[macro_use]
+extern crate clap;
+#[macro_use]
+extern crate error_chain;
+#[macro_use]
+extern crate log;
+
+pub mod error;
+
+use codec::Slicable;
+use demo_runtime::genesismap::{additional_storage_with_genesis, GenesisConfig};
+use client::genesis;
+
+/// Parse command line arguments and start the node.
+///
+/// IANA unassigned port ranges that we could use:
+/// 6717-6766		Unassigned
+/// 8504-8553		Unassigned
+/// 9556-9591		Unassigned
+/// 9803-9874		Unassigned
+/// 9926-9949		Unassigned
+pub fn run<I, T>(args: I) -> error::Result<()> where
+	I: IntoIterator<Item = T>,
+	T: Into<std::ffi::OsString> + Clone,
+{
+	let yaml = load_yaml!("./cli.yml");
+	let matches = clap::App::from_yaml(yaml).version(crate_version!()).get_matches_from_safe(args)?;
+
+	// TODO [ToDr] Split parameters parsing from actual execution.
+	let log_pattern = matches.value_of("log").unwrap_or("");
+	init_logger(log_pattern);
+
+	// Create client
+	let executor = demo_executor::Executor::new();
+	let mut storage = Default::default();
+	let god_key = hex!["3d866ec8a9190c8343c2fc593d21d8a6d0c5c4763aaab2349de3a6111d64d124"];
+
+	let genesis_config = GenesisConfig {
+		validators: vec![god_key.clone()],
+		authorities: vec![god_key.clone()],
+		balances: vec![(god_key.clone(), 1u64 << 63)].into_iter().collect(),
+		block_time: 5,			// 5 second block time.
+		session_length: 720,	// that's 1 hour per session.
+		sessions_per_era: 24,	// 24 hours per era.
+		bonding_duration: 90,	// 90 days per bond.
+		approval_ratio: 667,	// 66.7% approvals required for legislation.
+	};
+	let prepare_genesis = || {
+		storage = genesis_config.genesis_map();
+		let block = genesis::construct_genesis_block(&storage);
+		storage.extend(additional_storage_with_genesis(&block));
+		(primitives::block::Header::decode(&mut block.header.encode().as_ref()).expect("to_vec() always gives a valid serialisation; qed"), storage.into_iter().collect())
+	};
+	let client = client::new_in_mem(executor, prepare_genesis)?;
+
+	let address = "127.0.0.1:9933".parse().unwrap();
+	let handler = rpc::rpc_handler(client);
+	let server = rpc::start_http(&address, handler)?;
+
+	if let Some(_) = matches.subcommand_matches("collator") {
+		info!("Starting collator.");
+		server.wait();
+		return Ok(());
+	}
+
+	if let Some(_) = matches.subcommand_matches("validator") {
+		info!("Starting validator.");
+		server.wait();
+		return Ok(());
+	}
+
+	println!("No command given.\n");
+	let _ = clap::App::from_yaml(yaml).print_long_help();
+
+	Ok(())
+}
+
+fn init_logger(pattern: &str) {
+	let mut builder = env_logger::LogBuilder::new();
+	// Disable info logging by default for some modules:
+	builder.filter(Some("hyper"), log::LogLevelFilter::Warn);
+	// Enable info for others.
+	builder.filter(None, log::LogLevelFilter::Info);
+
+	if let Ok(lvl) = std::env::var("RUST_LOG") {
+		builder.parse(&lvl);
+	}
+
+	builder.parse(pattern);
+
+
+	builder.init().expect("Logger initialized only once.");
+}

substrate/demo/executor/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "demo-executor"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate Demo node implementation in Rust."
+
+[dependencies]
+hex-literal = "0.1"
+triehash = { version = "0.1" }
+ed25519 = { path = "../../substrate/ed25519" }
+substrate-codec = { path = "../../substrate/codec" }
+substrate-runtime-io = { path = "../../substrate/runtime-io" }
+substrate-runtime-support = { path = "../../substrate/runtime-support" }
+substrate-state-machine = { path = "../../substrate/state-machine" }
+substrate-executor = { path = "../../substrate/executor" }
+substrate-primitives = { path = "../../substrate/primitives" }
+demo-primitives = { path = "../primitives" }
+demo-runtime = { path = "../runtime" }
+
+[dev-dependencies]
+substrate-keyring = { path = "../../substrate/keyring" }

substrate/demo/executor/src/lib.rs

@@ -0,0 +1,280 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! A `CodeExecutor` specialisation which uses natively compiled runtime when the wasm to be
+//! executed is equivalent to the natively compiled code.
+
+extern crate demo_runtime;
+#[macro_use] extern crate substrate_executor;
+extern crate substrate_codec as codec;
+extern crate substrate_state_machine as state_machine;
+extern crate substrate_runtime_io as runtime_io;
+extern crate substrate_primitives as primitives;
+extern crate demo_primitives;
+extern crate ed25519;
+extern crate triehash;
+
+#[cfg(test)] extern crate substrate_keyring as keyring;
+#[cfg(test)] extern crate substrate_runtime_support as runtime_support;
+#[cfg(test)] #[macro_use] extern crate hex_literal;
+
+native_executor_instance!(pub Executor, demo_runtime::api::dispatch, include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm"));
+
+#[cfg(test)]
+mod tests {
+	use runtime_io;
+	use super::Executor;
+	use substrate_executor::WasmExecutor;
+	use codec::{KeyedVec, Slicable, Joiner};
+	use keyring::Keyring;
+	use runtime_support::Hashable;
+	use demo_runtime::runtime::staking::balance;
+	use state_machine::{CodeExecutor, TestExternalities};
+	use primitives::twox_128;
+	use demo_primitives::{Hash, Header, BlockNumber, Block, Digest, Transaction,
+		UncheckedTransaction, Function};
+	use ed25519::{Public, Pair};
+
+	const BLOATY_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
+	const COMPACT_CODE: &[u8] = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm");
+
+	// TODO: move into own crate.
+	macro_rules! map {
+		($( $name:expr => $value:expr ),*) => (
+			vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+		)
+	}
+
+	fn tx() -> UncheckedTransaction {
+		let transaction = Transaction {
+			signed: Keyring::One.to_raw_public(),
+			nonce: 0,
+			function: Function::StakingTransfer(Keyring::Two.to_raw_public(), 69),
+		};
+		let signature = Keyring::from_raw_public(transaction.signed).unwrap()
+			.sign(&transaction.encode());
+
+		UncheckedTransaction { transaction, signature }
+	}
+
+	#[test]
+	fn panic_execution_with_foreign_code_gives_error() {
+		let one = Keyring::One.to_raw_public();
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_err());
+	}
+
+	#[test]
+	fn panic_execution_with_native_equivalent_code_gives_error() {
+		let one = Keyring::One.to_raw_public();
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_err());
+	}
+
+	#[test]
+	fn successful_execution_with_native_equivalent_code_gives_ok() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let r = Executor::new().call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_ok());
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 69);
+		});
+	}
+
+	#[test]
+	fn successful_execution_with_foreign_code_gives_ok() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let r = Executor::new().call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_ok());
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 69);
+		});
+	}
+
+	fn new_test_ext() -> TestExternalities {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+
+		map![
+			twox_128(&0u64.to_keyed_vec(b"sys:old:")).to_vec() => [69u8; 32].encode(),
+			twox_128(b"gov:apr").to_vec() => vec![].and(&667u32),
+			twox_128(b"ses:len").to_vec() => vec![].and(&2u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"ses:val:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"ses:val:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"ses:val:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:wil:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"sta:wil:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"sta:wil:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"sta:wil:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:spe").to_vec() => vec![].and(&2u64),
+			twox_128(b"sta:vac").to_vec() => vec![].and(&3u64),
+			twox_128(b"sta:era").to_vec() => vec![].and(&0u64),
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		]
+	}
+
+	fn construct_block(number: BlockNumber, parent_hash: Hash, state_root: Hash, txs: Vec<Transaction>) -> (Vec<u8>, Hash) {
+		use triehash::ordered_trie_root;
+
+		let transactions = txs.into_iter().map(|transaction| {
+			let signature = Pair::from(Keyring::from_public(Public::from_raw(transaction.signed)).unwrap())
+				.sign(&transaction.encode());
+
+			UncheckedTransaction { transaction, signature }
+		}).collect::<Vec<_>>();
+
+		let transaction_root = ordered_trie_root(transactions.iter().map(Slicable::encode)).0.into();
+
+		let header = Header {
+			parent_hash,
+			number,
+			state_root,
+			transaction_root,
+			digest: Digest { logs: vec![], },
+		};
+		let hash = header.blake2_256();
+
+		(Block { header, transactions }.encode(), hash.into())
+	}
+
+	fn block1() -> (Vec<u8>, Hash) {
+		construct_block(
+			1,
+			[69u8; 32].into(),
+			hex!("2481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29db").into(),
+			vec![Transaction {
+				signed: Keyring::One.to_raw_public(),
+				nonce: 0,
+				function: Function::StakingTransfer(Keyring::Two.to_raw_public(), 69),
+			}]
+		)
+	}
+
+	fn block2() -> (Vec<u8>, Hash) {
+		construct_block(
+			2,
+			block1().1,
+			hex!("1feb4d3a2e587079e6ce1685fa79994efd995e33cb289d39cded67aac1bb46a9").into(),
+			vec![
+				Transaction {
+					signed: Keyring::Two.to_raw_public(),
+					nonce: 0,
+					function: Function::StakingTransfer(Keyring::One.to_raw_public(), 5),
+				},
+				Transaction {
+					signed: Keyring::One.to_raw_public(),
+					nonce: 1,
+					function: Function::StakingTransfer(Keyring::Two.to_raw_public(), 15),
+				}
+			]
+		)
+	}
+
+	#[test]
+	fn full_native_block_import_works() {
+		let mut t = new_test_ext();
+
+		Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&Keyring::One.to_raw_public()), 42);
+			assert_eq!(balance(&Keyring::Two.to_raw_public()), 69);
+		});
+
+		Executor::new().call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&Keyring::One.to_raw_public()), 32);
+			assert_eq!(balance(&Keyring::Two.to_raw_public()), 79);
+		});
+	}
+
+	#[test]
+	fn full_wasm_block_import_works() {
+		let mut t = new_test_ext();
+
+		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&Keyring::One.to_raw_public()), 42);
+			assert_eq!(balance(&Keyring::Two.to_raw_public()), 69);
+		});
+
+		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&Keyring::One.to_raw_public()), 32);
+			assert_eq!(balance(&Keyring::Two.to_raw_public()), 79);
+		});
+	}
+
+	#[test]
+	fn panic_execution_gives_error() {
+		let one = Keyring::One.to_raw_public();
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.wasm");
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_err());
+	}
+
+	#[test]
+	fn successful_execution_gives_ok() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let foreign_code = include_bytes!("../../runtime/wasm/target/wasm32-unknown-unknown/release/demo_runtime.compact.wasm");
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].and(&Header::from_block_number(1u64)).and(&tx()));
+		assert!(r.is_ok());
+
+		runtime_io::with_externalities(&mut t, || {
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 69);
+		});
+	}
+}

substrate/demo/primitives/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "demo-primitives"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+serde = { version = "1.0", default_features = false }
+serde_derive = { version = "1.0", optional = true }
+substrate-codec = { path = "../../substrate/codec", default_features = false }
+substrate-primitives = { path = "../../substrate/primitives", default_features = false }
+substrate-runtime-std = { path = "../../substrate/runtime-std", default_features = false }
+
+[dev-dependencies]
+substrate-serializer = { path = "../../substrate/serializer" }
+pretty_assertions = "0.4"
+
+[features]
+default = ["std"]
+std = [
+	"substrate-codec/std",
+	"substrate-primitives/std",
+	"substrate-runtime-std/std",
+	"serde_derive",
+	"serde/std",
+]

substrate/demo/primitives/src/block.rs

@@ -0,0 +1,189 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Block and header type definitions.
+
+#[cfg(feature = "std")]
+use primitives::bytes;
+use primitives::H256;
+use rstd::vec::Vec;
+use codec::{Input, Slicable};
+use transaction::UncheckedTransaction;
+
+pub use primitives::block::Id;
+
+/// Used to refer to a block number.
+pub type Number = u64;
+
+/// Hash used to refer to a block hash.
+pub type HeaderHash = H256;
+
+/// Hash used to refer to a transaction hash.
+pub type TransactionHash = H256;
+
+/// Execution log (event)
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Log(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
+
+impl Slicable for Log {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Vec::<u8>::decode(input).map(Log)
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(f)
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Log { }
+
+/// The digest of a block, useful for light-clients.
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Digest {
+	/// All logs that have happened in the block.
+	pub logs: Vec<Log>,
+}
+
+impl Slicable for Digest {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Vec::<Log>::decode(input).map(|logs| Digest { logs })
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.logs.using_encoded(f)
+	}
+}
+
+/// The block "body": A bunch of transactions.
+pub type Body = Vec<UncheckedTransaction>;
+
+/// A Polkadot relay chain block.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Block {
+	/// The block header.
+	pub header: Header,
+	/// All relay-chain transactions.
+	pub transactions: Body,
+}
+
+impl Slicable for Block {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let (header, transactions) = try_opt!(Slicable::decode(input));
+		Some(Block { header, transactions })
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		v.extend(self.header.encode());
+		v.extend(self.transactions.encode());
+
+		v
+	}
+}
+
+/// A relay chain block header.
+///
+/// https://github.com/w3f/polkadot-spec/blob/master/spec.md#header
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "std", serde(deny_unknown_fields))]
+pub struct Header {
+	/// Block parent's hash.
+	pub parent_hash: HeaderHash,
+	/// Block number.
+	pub number: Number,
+	/// State root after this transition.
+	pub state_root: H256,
+	/// The root of the trie that represents this block's transactions, indexed by a 32-byte integer.
+	pub transaction_root: H256,
+	/// The digest of activity on the block.
+	pub digest: Digest,
+}
+
+impl Header {
+	/// Create a new instance with default fields except `number`, which is given as an argument.
+	pub fn from_block_number(number: Number) -> Self {
+		Header {
+			parent_hash: Default::default(),
+			number,
+			state_root: Default::default(),
+			transaction_root: Default::default(),
+			digest: Default::default(),
+		}
+	}
+}
+
+impl Slicable for Header {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Header {
+			parent_hash: try_opt!(Slicable::decode(input)),
+			number: try_opt!(Slicable::decode(input)),
+			state_root: try_opt!(Slicable::decode(input)),
+			transaction_root: try_opt!(Slicable::decode(input)),
+			digest: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.parent_hash.using_encoded(|s| v.extend(s));
+		self.number.using_encoded(|s| v.extend(s));
+		self.state_root.using_encoded(|s| v.extend(s));
+		self.transaction_root.using_encoded(|s| v.extend(s));
+		self.digest.using_encoded(|s| v.extend(s));
+
+		v
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Slicable;
+	use substrate_serializer as ser;
+
+	#[test]
+	fn test_header_serialization() {
+		let header = Header {
+			parent_hash: 5.into(),
+			number: 67,
+			state_root: 3.into(),
+			transaction_root: 6.into(),
+			digest: Digest { logs: vec![Log(vec![1])] },
+		};
+
+		assert_eq!(ser::to_string_pretty(&header), r#"{
+  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000005",
+  "number": 67,
+  "stateRoot": "0x0000000000000000000000000000000000000000000000000000000000000003",
+  "transactionRoot": "0x0000000000000000000000000000000000000000000000000000000000000006",
+  "digest": {
+    "logs": [
+      "0x01"
+    ]
+  }
+}"#);
+
+		let v = header.encode();
+		assert_eq!(Header::decode(&mut &v[..]).unwrap(), header);
+	}
+}

substrate/demo/primitives/src/lib.rs

@@ -0,0 +1,77 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Shareable Polkadot types.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+#[cfg(feature = "std")]
+extern crate serde;
+
+extern crate substrate_runtime_std as rstd;
+extern crate substrate_primitives as primitives;
+#[cfg(test)]
+extern crate substrate_serializer;
+
+extern crate substrate_codec as codec;
+
+macro_rules! try_opt {
+	($e: expr) => {
+		match $e {
+			Some(x) => x,
+			None => return None,
+		}
+	}
+}
+
+pub mod block;
+pub mod transaction;
+
+pub use self::block::{Header, Block, Log, Digest};
+pub use self::block::Number as BlockNumber;
+pub use self::transaction::{Transaction, UncheckedTransaction, Function, Proposal};
+
+/// Virtual account ID that represents the idea of a dispatch/statement being signed by everybody
+/// (who matters). Essentially this means that a majority of validators have decided it is
+/// "correct".
+pub const EVERYBODY: AccountId = [255u8; 32];
+
+/// Alias to Ed25519 pubkey that identifies an account on the relay chain. This will almost
+/// certainly continue to be the same as the substrate's `AuthorityId`.
+pub type AccountId = primitives::AuthorityId;
+
+/// The Ed25519 pub key of an session that belongs to an authority of the relay chain. This is
+/// exactly equivalent to what the substrate calls an "authority".
+pub type SessionKey = primitives::AuthorityId;
+
+/// Indentifier for a chain.
+pub type ChainID = u64;
+
+/// Index of a transaction in the relay chain.
+pub type TxOrder = u64;
+
+/// A hash of some data used by the relay chain.
+pub type Hash = primitives::H256;
+
+/// Alias to 520-bit hash when used in the context of a signature on the relay chain.
+pub type Signature = primitives::hash::H512;

substrate/demo/primitives/src/transaction.rs

@@ -0,0 +1,390 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Transaction type.
+
+use rstd::vec::Vec;
+use codec::{Input, Slicable};
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+use block::Number as BlockNumber;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum InternalFunctionId {
+	/// Set the system's code.
+	SystemSetCode = 0x00,
+
+	/// Set the session length.
+	SessionSetLength = 0x10,
+	/// Force a new session.
+	SessionForceNewSession = 0x11,
+
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra = 0x20,
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration = 0x21,
+	/// Set the validator count for staking.
+	StakingSetValidatorCount = 0x22,
+	/// Force a new staking era.
+	StakingForceNewEra = 0x23,
+
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired = 0x30,
+
+}
+
+impl InternalFunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<InternalFunctionId> {
+		let functions = [
+			InternalFunctionId::SystemSetCode,
+			InternalFunctionId::SessionSetLength,
+			InternalFunctionId::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra,
+			InternalFunctionId::StakingSetBondingDuration,
+			InternalFunctionId::StakingSetValidatorCount,
+			InternalFunctionId::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired,
+		];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Internal functions that can be dispatched to.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Proposal {
+	/// Set the system's code.
+	SystemSetCode(Vec<u8>),
+	/// Set the session length.
+	SessionSetLength(BlockNumber),
+	/// Force a new session.
+	SessionForceNewSession,
+	/// Set the number of sessions per era.
+	StakingSetSessionsPerEra(BlockNumber),
+	/// Set the minimum bonding duration for staking.
+	StakingSetBondingDuration(BlockNumber),
+	/// Set the validator count for staking.
+	StakingSetValidatorCount(u32),
+	/// Force a new staking era.
+	StakingForceNewEra,
+	/// Set the per-mille of validator approval required for governance changes.
+	GovernanceSetApprovalPpmRequired(u32),
+
+}
+
+impl Slicable for Proposal {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let id = try_opt!(u8::decode(input).and_then(InternalFunctionId::from_u8));
+		let function = match id {
+			InternalFunctionId::SystemSetCode =>
+				Proposal::SystemSetCode(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::SessionSetLength =>
+				Proposal::SessionSetLength(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::SessionForceNewSession => Proposal::SessionForceNewSession,
+			InternalFunctionId::StakingSetSessionsPerEra =>
+				Proposal::StakingSetSessionsPerEra(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingSetBondingDuration =>
+				Proposal::StakingSetBondingDuration(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingSetValidatorCount =>
+				Proposal::StakingSetValidatorCount(try_opt!(Slicable::decode(input))),
+			InternalFunctionId::StakingForceNewEra => Proposal::StakingForceNewEra,
+			InternalFunctionId::GovernanceSetApprovalPpmRequired =>
+				Proposal::GovernanceSetApprovalPpmRequired(try_opt!(Slicable::decode(input))),
+		};
+
+		Some(function)
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Proposal::SystemSetCode(ref data) => {
+				(InternalFunctionId::SystemSetCode as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::SessionSetLength(ref data) => {
+				(InternalFunctionId::SessionSetLength as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::SessionForceNewSession => {
+				(InternalFunctionId::SessionForceNewSession as u8).using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetSessionsPerEra(ref data) => {
+				(InternalFunctionId::StakingSetSessionsPerEra as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetBondingDuration(ref data) => {
+				(InternalFunctionId::StakingSetBondingDuration as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingSetValidatorCount(ref data) => {
+				(InternalFunctionId::StakingSetValidatorCount as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Proposal::StakingForceNewEra => {
+				(InternalFunctionId::StakingForceNewEra as u8).using_encoded(|s| v.extend(s));
+			}
+			Proposal::GovernanceSetApprovalPpmRequired(ref data) => {
+				(InternalFunctionId::GovernanceSetApprovalPpmRequired as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+}
+
+/// Public functions that can be dispatched to.
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[repr(u8)]
+enum FunctionId {
+	/// Set the timestamp.
+	TimestampSet = 0x00,
+	/// Set temporary session key as a validator.
+	SessionSetKey = 0x10,
+	/// Staking subsystem: begin staking.
+	StakingStake = 0x20,
+	/// Staking subsystem: stop staking.
+	StakingUnstake = 0x21,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer = 0x22,
+	/// Make a proposal for the governance system.
+	GovernancePropose = 0x30,
+	/// Approve a proposal for the governance system.
+	GovernanceApprove = 0x31,
+}
+
+impl FunctionId {
+	/// Derive `Some` value from a `u8`, or `None` if it's invalid.
+	fn from_u8(value: u8) -> Option<FunctionId> {
+		use self::*;
+		let functions = [FunctionId::StakingStake, FunctionId::StakingUnstake,
+			FunctionId::StakingTransfer, FunctionId::SessionSetKey, FunctionId::TimestampSet,
+			FunctionId::GovernancePropose, FunctionId::GovernanceApprove];
+		functions.iter().map(|&f| f).find(|&f| value == f as u8)
+	}
+}
+
+/// Functions on the runtime.
+#[derive(Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub enum Function {
+	/// Set the timestamp.
+	TimestampSet(u64),
+	/// Set temporary session key as a validator.
+	SessionSetKey(::SessionKey),
+	/// Staking subsystem: begin staking.
+	StakingStake,
+	/// Staking subsystem: stop staking.
+	StakingUnstake,
+	/// Staking subsystem: transfer stake.
+	StakingTransfer(::AccountId, u64),
+	/// Make a proposal for the governance system.
+	GovernancePropose(Proposal),
+	/// Approve a proposal for the governance system.
+	GovernanceApprove(BlockNumber),
+}
+
+impl Slicable for Function {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		let id = try_opt!(u8::decode(input).and_then(FunctionId::from_u8));
+		Some(match id {
+			FunctionId::TimestampSet =>
+				Function::TimestampSet(try_opt!(Slicable::decode(input))),
+			FunctionId::SessionSetKey =>
+				Function::SessionSetKey(try_opt!(Slicable::decode(input))),
+			FunctionId::StakingStake => Function::StakingStake,
+			FunctionId::StakingUnstake => Function::StakingUnstake,
+			FunctionId::StakingTransfer => {
+				let to  = try_opt!(Slicable::decode(input));
+				let amount = try_opt!(Slicable::decode(input));
+
+				Function::StakingTransfer(to, amount)
+			}
+			FunctionId::GovernancePropose =>
+				Function::GovernancePropose(try_opt!(Slicable::decode(input))),
+			FunctionId::GovernanceApprove =>
+				Function::GovernanceApprove(try_opt!(Slicable::decode(input))),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+		match *self {
+			Function::TimestampSet(ref data) => {
+				(FunctionId::TimestampSet as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::SessionSetKey(ref data) => {
+				(FunctionId::SessionSetKey as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::StakingStake => {
+				(FunctionId::StakingStake as u8).using_encoded(|s| v.extend(s));
+			}
+			Function::StakingUnstake => {
+				(FunctionId::StakingUnstake as u8).using_encoded(|s| v.extend(s));
+			}
+			Function::StakingTransfer(ref to, ref amount) => {
+				(FunctionId::StakingTransfer as u8).using_encoded(|s| v.extend(s));
+				to.using_encoded(|s| v.extend(s));
+				amount.using_encoded(|s| v.extend(s));
+			}
+			Function::GovernancePropose(ref data) => {
+				(FunctionId::GovernancePropose as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+			Function::GovernanceApprove(ref data) => {
+				(FunctionId::GovernanceApprove as u8).using_encoded(|s| v.extend(s));
+				data.using_encoded(|s| v.extend(s));
+			}
+		}
+
+		v
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(self.encode().as_slice())
+	}
+}
+
+/// A vetted and verified transaction from the external world.
+#[derive(PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+pub struct Transaction {
+	/// Who signed it (note this is not a signature).
+	pub signed: super::AccountId,
+	/// The number of transactions have come before from the same signer.
+	pub nonce: super::TxOrder,
+	/// The function that should be called.
+	pub function: Function,
+}
+
+impl Slicable for Transaction {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		Some(Transaction {
+			signed: try_opt!(Slicable::decode(input)),
+			nonce: try_opt!(Slicable::decode(input)),
+			function: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		self.signed.using_encoded(|s| v.extend(s));
+		self.nonce.using_encoded(|s| v.extend(s));
+		self.function.using_encoded(|s| v.extend(s));
+
+		v
+	}
+}
+
+impl ::codec::NonTrivialSlicable for Transaction {}
+
+/// A transactions right from the external world. Unchecked.
+#[derive(Eq, Clone)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct UncheckedTransaction {
+	/// The actual transaction information.
+	pub transaction: Transaction,
+	/// The signature; should be an Ed25519 signature applied to the serialised `transaction` field.
+	pub signature: super::Signature,
+}
+
+impl Slicable for UncheckedTransaction {
+	fn decode<I: Input>(input: &mut I) -> Option<Self> {
+		// This is a little more complicated than usual since the binary format must be compatible
+		// with substrate's generic `Vec<u8>` type. Basically this just means accepting that there
+		// will be a prefix of u32, which has the total number of bytes following (we don't need
+		// to use this).
+		let _length_do_not_remove_me_see_above: u32 = try_opt!(Slicable::decode(input));
+
+		Some(UncheckedTransaction {
+			transaction: try_opt!(Slicable::decode(input)),
+			signature: try_opt!(Slicable::decode(input)),
+		})
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		// need to prefix with the total length as u32 to ensure it's binary comptible with
+		// Vec<u8>. we'll make room for it here, then overwrite once we know the length.
+		v.extend(&[0u8; 4]);
+
+		self.transaction.signed.using_encoded(|s| v.extend(s));
+		self.transaction.nonce.using_encoded(|s| v.extend(s));
+		self.transaction.function.using_encoded(|s| v.extend(s));
+		self.signature.using_encoded(|s| v.extend(s));
+
+		let length = (v.len() - 4) as u32;
+		length.using_encoded(|s| v[0..4].copy_from_slice(s));
+
+		v
+	}
+}
+
+impl ::codec::NonTrivialSlicable for UncheckedTransaction {}
+
+impl PartialEq for UncheckedTransaction {
+	fn eq(&self, other: &Self) -> bool {
+		self.signature.iter().eq(other.signature.iter()) && self.transaction == other.transaction
+	}
+}
+
+#[cfg(feature = "std")]
+impl fmt::Debug for UncheckedTransaction {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "UncheckedTransaction({:?})", self.transaction)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use primitives;
+	use ::codec::Slicable;
+	use primitives::hexdisplay::HexDisplay;
+
+	#[test]
+	fn serialize_unchecked() {
+		let tx = UncheckedTransaction {
+			transaction: Transaction {
+				signed: [1; 32],
+				nonce: 999u64,
+				function: Function::TimestampSet(135135),
+			},
+			signature: primitives::hash::H512([0; 64]),
+		};
+		// 71000000
+		// 0101010101010101010101010101010101010101010101010101010101010101
+		// e703000000000000
+		// 00
+		// df0f0200
+		// 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
+
+		let v = Slicable::encode(&tx);
+		println!("{}", HexDisplay::from(&v));
+		assert_eq!(UncheckedTransaction::decode(&mut &v[..]).unwrap(), tx);
+	}
+}

substrate/demo/runtime/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "demo-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[dependencies]
+rustc-hex = "1.0"
+hex-literal = "0.1.0"
+log = { version = "0.3", optional = true }
+substrate-codec = { path = "../../substrate/codec" }
+substrate-runtime-std = { path = "../../substrate/runtime-std" }
+substrate-runtime-io = { path = "../../substrate/runtime-io" }
+substrate-runtime-support = { path = "../../substrate/runtime-support" }
+substrate-primitives = { path = "../../substrate/primitives" }
+demo-primitives = { path = "../primitives" }
+
+[dev-dependencies]
+substrate-keyring = { path = "../../substrate/keyring" }
+
+[features]
+default = ["std"]
+std = [
+	"substrate-codec/std",
+	"substrate-runtime-std/std",
+	"substrate-runtime-io/std",
+	"substrate-runtime-support/std",
+	"substrate-primitives/std",
+	"demo-primitives/std",
+	"log"
+]

substrate/demo/runtime/src/api.rs

@@ -0,0 +1,26 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+use runtime::{system, consensus, session};
+
+impl_stubs!(
+	execute_block => |block| system::internal::execute_block(block),
+	execute_transaction => |(header, utx)| system::internal::execute_transaction(utx, header),
+	finalise_block => |header| system::internal::finalise_block(header),
+	validator_count => |()| session::validator_count(),
+	validators => |()| session::validators(),
+	authorities => |()| consensus::authorities()
+);

substrate/demo/runtime/src/environment.rs

@@ -0,0 +1,82 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Environment API: Allows certain information to be accessed throughout the runtime.
+
+use rstd::boxed::Box;
+use rstd::mem;
+use rstd::cell::RefCell;
+use rstd::rc::Rc;
+
+use demo_primitives::{BlockNumber, Digest, Hash};
+
+#[derive(Default)]
+/// The information that can be accessed globally.
+pub struct Environment {
+	/// The current block number.
+	pub block_number: BlockNumber,
+	/// The current block's parent hash.
+	pub parent_hash: Hash,
+	/// The current block digest.
+	pub digest: Digest,
+}
+
+/// Do something with the environment and return its value. Keep the function short.
+pub fn with_env<T, F: FnOnce(&mut Environment) -> T>(f: F) -> T {
+	let e = env();
+	let mut eb = e.borrow_mut();
+	f(&mut *eb)
+}
+
+#[cfg(target_arch = "wasm32")]
+fn env() -> Rc<RefCell<Environment>> {
+	// Initialize it to a null value
+	static mut SINGLETON: *const Rc<RefCell<Environment>> = 0 as *const Rc<RefCell<Environment>>;
+
+	unsafe {
+		if SINGLETON == 0 as *const Rc<RefCell<Environment>> {
+			// Make it
+			let singleton: Rc<RefCell<Environment>> = Rc::new(RefCell::new(Default::default()));
+
+			// Put it in the heap so it can outlive this call
+			SINGLETON = mem::transmute(Box::new(singleton));
+		}
+
+		// Now we give out a copy of the data that is safe to use concurrently.
+		(*SINGLETON).clone()
+	}
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn env() -> Rc<RefCell<Environment>> {
+	// Initialize it to a null value
+	thread_local!{
+		static SINGLETON: RefCell<*const Rc<RefCell<Environment>>> = RefCell::new(0 as *const Rc<RefCell<Environment>>);
+	}
+
+	SINGLETON.with(|s| unsafe {
+		if *s.borrow() == 0 as *const Rc<RefCell<Environment>> {
+			// Make it
+			let singleton: Rc<RefCell<Environment>> = Rc::new(RefCell::new(Default::default()));
+
+			// Put it in the heap so it can outlive this call
+			*s.borrow_mut() = mem::transmute(Box::new(singleton));
+		}
+
+		// Now we give out a copy of the data that is safe to use concurrently.
+		(**s.borrow()).clone()
+	})
+}

substrate/demo/runtime/src/genesismap.rs

@@ -0,0 +1,92 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Tool for creating the genesis block.
+
+use codec::{KeyedVec, Joiner};
+use std::collections::HashMap;
+use runtime_io::twox_128;
+use runtime_support::Hashable;
+use primitives::Block;
+use demo_primitives::{BlockNumber, AccountId};
+use runtime::staking::Balance;
+
+/// Configuration of a general Substrate Demo genesis block.
+pub struct GenesisConfig {
+	pub validators: Vec<AccountId>,
+	pub authorities: Vec<AccountId>,
+	pub balances: Vec<(AccountId, Balance)>,
+	pub block_time: u64,
+	pub session_length: BlockNumber,
+	pub sessions_per_era: BlockNumber,
+	pub bonding_duration: BlockNumber,
+	pub approval_ratio: u32,
+}
+
+impl GenesisConfig {
+	pub fn new_simple(authorities_validators: Vec<AccountId>, balance: Balance) -> Self {
+		GenesisConfig {
+			validators: authorities_validators.clone(),
+			authorities: authorities_validators.clone(),
+			balances: authorities_validators.iter().map(|v| (v.clone(), balance)).collect(),
+			block_time: 5,			// 5 second block time.
+			session_length: 720,	// that's 1 hour per session.
+			sessions_per_era: 24,	// 24 hours per era.
+			bonding_duration: 90,	// 90 days per bond.
+			approval_ratio: 667,	// 66.7% approvals required for legislation.
+		}
+	}
+
+	pub fn genesis_map(&self) -> HashMap<Vec<u8>, Vec<u8>> {
+		let wasm_runtime = include_bytes!("../wasm/genesis.wasm").to_vec();
+		vec![
+			(&b"gov:apr"[..], vec![].and(&self.approval_ratio)),
+			(&b"ses:len"[..], vec![].and(&self.session_length)),
+			(&b"ses:val:len"[..], vec![].and(&(self.validators.len() as u32))),
+			(&b"sta:wil:len"[..], vec![].and(&0u32)),
+			(&b"sta:spe"[..], vec![].and(&self.sessions_per_era)),
+			(&b"sta:vac"[..], vec![].and(&(self.validators.len() as u32))),
+			(&b"sta:era"[..], vec![].and(&0u64)),
+		].into_iter()
+			.map(|(k, v)| (k.into(), v))
+			.chain(self.validators.iter()
+				.enumerate()
+				.map(|(i, account)| ((i as u32).to_keyed_vec(b"ses:val:"), vec![].and(account)))
+			).chain(self.authorities.iter()
+				.enumerate()
+				.map(|(i, account)| ((i as u32).to_keyed_vec(b":auth:"), vec![].and(account)))
+			).chain(self.balances.iter()
+				.map(|&(account, balance)| (account.to_keyed_vec(b"sta:bal:"), vec![].and(&balance)))
+			)
+			.map(|(k, v)| (twox_128(&k[..])[..].to_vec(), v.to_vec()))
+			.chain(vec![
+				(b":code"[..].into(), wasm_runtime),
+				(b":auth:len"[..].into(), vec![].and(&(self.authorities.len() as u32))),
+			].into_iter())
+			.chain(self.authorities.iter()
+				.enumerate()
+				.map(|(i, account)| ((i as u32).to_keyed_vec(b":auth:"), vec![].and(account)))
+			)
+			.collect()
+	}
+}
+
+pub fn additional_storage_with_genesis(genesis_block: &Block) -> HashMap<Vec<u8>, Vec<u8>> {
+	use codec::Slicable;
+	map![
+		twox_128(&0u64.to_keyed_vec(b"sys:old:")).to_vec() => genesis_block.header.blake2_256().encode()
+	]
+}

substrate/demo/runtime/src/lib.rs

@@ -0,0 +1,77 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! The Substrate Demo runtime. This can be compiled with #[no_std], ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate substrate_runtime_std as rstd;
+#[macro_use] extern crate substrate_runtime_io as runtime_io;
+extern crate substrate_runtime_support as runtime_support;
+#[cfg(all(feature = "std", test))] extern crate substrate_keyring as keyring;
+
+#[cfg(feature = "std")] extern crate rustc_hex;
+
+extern crate substrate_codec as codec;
+#[cfg(feature = "std")] #[macro_use] extern crate substrate_primitives as primitives;
+extern crate demo_primitives;
+
+#[cfg(test)] #[macro_use] extern crate hex_literal;
+
+pub mod environment;
+pub mod runtime;
+pub mod api;
+
+#[cfg(feature = "std")] pub mod genesismap;
+
+/// Type definitions and helpers for transactions.
+pub mod transaction {
+	use rstd::ops;
+	use demo_primitives::Signature;
+	pub use demo_primitives::{Transaction, UncheckedTransaction};
+
+	/// A type-safe indicator that a transaction has been checked.
+	#[derive(PartialEq, Eq, Clone)]
+	#[cfg_attr(feature = "std", derive(Debug))]
+	pub struct CheckedTransaction(UncheckedTransaction);
+
+	impl CheckedTransaction {
+		/// Get a reference to the checked signature.
+		pub fn signature(&self) -> &Signature {
+			&self.0.signature
+		}
+	}
+
+	impl ops::Deref for CheckedTransaction {
+		type Target = Transaction;
+
+		fn deref(&self) -> &Transaction {
+			&self.0.transaction
+		}
+	}
+
+	/// Check the signature on a transaction.
+	///
+	/// On failure, return the transaction back.
+	pub fn check(tx: UncheckedTransaction) -> Result<CheckedTransaction, UncheckedTransaction> {
+		let msg = ::codec::Slicable::encode(&tx.transaction);
+		if ::runtime_io::ed25519_verify(&tx.signature.0, &msg, &tx.transaction.signed) {
+			Ok(CheckedTransaction(tx))
+		} else {
+			Err(tx)
+		}
+	}
+}

substrate/demo/runtime/src/runtime/consensus.rs

@@ -0,0 +1,48 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Conensus module for runtime; manages the authority set ready for the native code.
+
+use rstd::prelude::*;
+use runtime_support::storage::unhashed::StorageVec;
+use demo_primitives::SessionKey;
+
+struct AuthorityStorageVec {}
+impl StorageVec for AuthorityStorageVec {
+	type Item = SessionKey;
+	const PREFIX: &'static[u8] = b":auth:";
+}
+
+/// Get the current set of authorities. These are the session keys.
+pub fn authorities() -> Vec<SessionKey> {
+	AuthorityStorageVec::items()
+}
+
+pub mod internal {
+	use super::*;
+
+	/// Set the current set of authorities' session keys.
+	///
+	/// Called by `next_session` only.
+	pub fn set_authorities(authorities: &[SessionKey]) {
+		AuthorityStorageVec::set_items(authorities);
+	}
+
+	/// Set a single authority by index.
+	pub fn set_authority(index: u32, key: &SessionKey) {
+		AuthorityStorageVec::set_item(index, key);
+	}
+}

substrate/demo/runtime/src/runtime/governance.rs

@@ -0,0 +1,371 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Governance system: Handles administration and dispatch of sensitive operations including
+//! setting new code, minting new tokens and changing parameters.
+//!
+//! For now this is limited to a simple qualified majority vote (whose parameter is retrieved from
+//! storage) between validators. A single vote may be proposed per era, and at most one approval
+//! vote may be cast by each validator. The tally is maintained through a simple tag in storage for
+//! each validator that has approved.
+//!
+//! At the end of the era, all validators approvals are tallied and if there are sufficient to pass
+//! the proposal then it is enacted. All items in storage concerning the proposal are reset.
+
+use rstd::prelude::*;
+use codec::KeyedVec;
+use runtime_support::storage;
+use demo_primitives::{Proposal, AccountId, Hash, BlockNumber};
+use runtime::{staking, system, session};
+
+const APPROVALS_REQUIRED: &[u8] = b"gov:apr";
+const CURRENT_PROPOSAL: &[u8] = b"gov:pro";
+const APPROVAL_OF: &[u8] = b"gov:app:";
+
+/// The proportion of validators required for a propsal to be approved measured as the number out
+/// of 1000.
+pub fn approval_ppm_required() -> u32 {
+	storage::get_or(APPROVALS_REQUIRED, 1000)
+}
+
+/// The number of concrete validator approvals required for a proposal to pass.
+pub fn approvals_required() -> u32 {
+	approval_ppm_required() * session::validator_count() / 1000
+}
+
+pub mod public {
+	use super::*;
+
+	/// Propose a sensitive action to be taken. Any action that is enactable by `Proposal` is valid.
+	/// Proposal is by the `transactor` and will automatically count as an approval. Transactor must
+	/// be a current validator. It is illegal to propose when there is already a proposal in effect.
+	pub fn propose(validator: &AccountId, proposal: &Proposal) {
+		if storage::exists(CURRENT_PROPOSAL) {
+			panic!("there may only be one proposal per era.");
+		}
+		storage::put(CURRENT_PROPOSAL, proposal);
+		approve(validator, staking::current_era());
+	}
+
+	/// Approve the current era's proposal. Transactor must be a validator. This may not be done more
+	/// than once for any validator in an era.
+	pub fn approve(validator: &AccountId, era_index: BlockNumber) {
+		if era_index != staking::current_era() {
+			panic!("approval vote applied on non-current era.")
+		}
+		if !storage::exists(CURRENT_PROPOSAL) {
+			panic!("there must be a proposal in order to approve.");
+		}
+		if session::validators().into_iter().position(|v| &v == validator).is_none() {
+			panic!("transactor must be a validator to approve.");
+		}
+		let key = validator.to_keyed_vec(APPROVAL_OF);
+		if storage::exists(&key) {
+			panic!("transactor may not approve a proposal twice in one era.");
+		}
+		storage::put(&key, &true);
+	}
+}
+
+pub mod privileged {
+	use super::*;
+
+	/// Set the proportion of validators that must approve for a proposal to be enacted at the end of
+	/// its era. The value, `ppm`, is measured as a fraction of 1000 rounded down to the nearest whole
+	/// validator. `1000` would require the approval of all validators; `667` would require two-thirds
+	/// (or there abouts) of validators.
+	pub fn set_approval_ppm_required(ppm: u32) {
+		storage::put(APPROVALS_REQUIRED, &ppm);
+	}
+}
+
+pub mod internal {
+	use super::*;
+	use demo_primitives::Proposal;
+
+	/// Current era is ending; we should finish up any proposals.
+	pub fn end_of_an_era() {
+		// tally up votes for the current proposal, if any. enact if there are sufficient approvals.
+		if let Some(proposal) = storage::take::<Proposal>(CURRENT_PROPOSAL) {
+			let approvals_required = approvals_required();
+			let approved = session::validators().into_iter()
+				.filter_map(|v| storage::take::<bool>(&v.to_keyed_vec(APPROVAL_OF)))
+				.take(approvals_required as usize)
+				.count() as u32;
+			if approved == approvals_required {
+				enact_proposal(proposal);
+			}
+		}
+	}
+
+	fn enact_proposal(proposal: Proposal) {
+		match proposal {
+			Proposal::SystemSetCode(code) => {
+				system::privileged::set_code(&code);
+			}
+			Proposal::SessionSetLength(value) => {
+				session::privileged::set_length(value);
+			}
+			Proposal::SessionForceNewSession => {
+				session::privileged::force_new_session();
+			}
+			Proposal::StakingSetSessionsPerEra(value) => {
+				staking::privileged::set_sessions_per_era(value);
+			}
+			Proposal::StakingSetBondingDuration(value) => {
+				staking::privileged::set_bonding_duration(value);
+			}
+			Proposal::StakingSetValidatorCount(value) => {
+				staking::privileged::set_validator_count(value);
+			}
+			Proposal::StakingForceNewEra => {
+				staking::privileged::force_new_era()
+			}
+			Proposal::GovernanceSetApprovalPpmRequired(value) => {
+				self::privileged::set_approval_ppm_required(value);
+			}
+
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{KeyedVec, Joiner};
+	use keyring::Keyring;
+	use environment::with_env;
+	use demo_primitives::{AccountId, Proposal};
+	use runtime::{staking, session};
+
+	fn new_test_ext() -> TestExternalities {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+
+		map![
+			twox_128(APPROVALS_REQUIRED).to_vec() => vec![].and(&667u32),
+			twox_128(b"ses:len").to_vec() => vec![].and(&1u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"ses:val:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"ses:val:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"ses:val:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:wil:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"sta:wil:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"sta:wil:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"sta:wil:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:spe").to_vec() => vec![].and(&1u64),
+			twox_128(b"sta:vac").to_vec() => vec![].and(&3u64),
+			twox_128(b"sta:era").to_vec() => vec![].and(&1u64)
+		]
+	}
+
+	#[test]
+	fn majority_voting_should_work() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Approve it. Era length changes.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::approve(&two, 1);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 2);
+		});
+	}
+
+	#[test]
+	fn majority_voting_should_work_after_unsuccessful_previous() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Fail it.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+
+			// Block 2: Make proposal. Approve it. It should change era length.
+			with_env(|e| e.block_number = 2);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::approve(&two, 2);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 2);
+		});
+	}
+
+	#[test]
+	fn minority_voting_should_not_succeed() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn old_voting_should_be_illegal() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::approve(&two, 0);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn double_voting_should_be_illegal() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::approve(&two, 1);
+			public::approve(&two, 1);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn over_proposing_should_be_illegal() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::propose(&two, &Proposal::StakingSetSessionsPerEra(2));
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn approving_without_proposal_should_be_illegal() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::approve(&two, 1);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn non_validator_approving_should_be_illegal() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let four = [4u8; 32];
+		let mut t = new_test_ext();
+
+		with_externalities(&mut t, || {
+			assert_eq!(staking::era_length(), 1u64);
+			assert_eq!(staking::current_era(), 1u64);
+			assert_eq!(session::validator_count(), 3u32);
+			assert_eq!(session::validators(), vec![one.clone(), two.clone(), three.clone()]);
+			assert!(!session::validators().into_iter().position(|v| &v == &one).is_none());
+
+			// Block 1: Make proposal. Will have only 1 vote. No change.
+			with_env(|e| e.block_number = 1);
+			public::propose(&one, &Proposal::StakingSetSessionsPerEra(2));
+			public::approve(&four, 1);
+			staking::internal::check_new_era();
+			assert_eq!(staking::era_length(), 1);
+		});
+	}
+}

substrate/demo/runtime/src/runtime/mod.rs

@@ -0,0 +1,32 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! The Polkadot runtime.
+
+#[allow(unused)]
+pub mod system;
+#[allow(unused)]
+pub mod consensus;
+#[allow(unused)]
+pub mod staking;
+#[allow(unused)]
+pub mod timestamp;
+#[allow(unused)]
+pub mod session;
+#[allow(unused)]
+pub mod governance;
+
+// TODO: polkadao

substrate/demo/runtime/src/runtime/session.rs

@@ -0,0 +1,250 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Session manager: is told the validators and allows them to manage their session keys for the
+//! consensus module.
+
+use rstd::prelude::*;
+use codec::KeyedVec;
+use runtime_support::{storage, StorageVec};
+use demo_primitives::{AccountId, SessionKey, BlockNumber};
+use runtime::{system, staking, consensus};
+
+const SESSION_LENGTH: &[u8] = b"ses:len";
+const CURRENT_INDEX: &[u8] = b"ses:ind";
+const LAST_LENGTH_CHANGE: &[u8] = b"ses:llc";
+const NEXT_KEY_FOR: &[u8] = b"ses:nxt:";
+const NEXT_SESSION_LENGTH: &[u8] = b"ses:nln";
+
+struct ValidatorStorageVec {}
+impl StorageVec for ValidatorStorageVec {
+	type Item = AccountId;
+	const PREFIX: &'static[u8] = b"ses:val:";
+}
+
+/// Get the current set of validators.
+pub fn validators() -> Vec<AccountId> {
+	ValidatorStorageVec::items()
+}
+
+/// The number of blocks in each session.
+pub fn length() -> BlockNumber {
+	storage::get_or(SESSION_LENGTH, 0)
+}
+
+/// The number of validators currently.
+pub fn validator_count() -> u32 {
+	ValidatorStorageVec::count() as u32
+}
+
+/// The current era index.
+pub fn current_index() -> BlockNumber {
+	storage::get_or(CURRENT_INDEX, 0)
+}
+
+/// The block number at which the era length last changed.
+pub fn last_length_change() -> BlockNumber {
+	storage::get_or(LAST_LENGTH_CHANGE, 0)
+}
+
+pub mod public {
+	use super::*;
+
+	/// Sets the session key of `_validator` to `_key`. This doesn't take effect until the next
+	/// session.
+	pub fn set_key(validator: &AccountId, key: &SessionKey) {
+		// set new value for next session
+		storage::put(&validator.to_keyed_vec(NEXT_KEY_FOR), key);
+	}
+}
+
+pub mod privileged {
+	use super::*;
+
+	/// Set a new era length. Won't kick in until the next era change (at current length).
+	pub fn set_length(new: BlockNumber) {
+		storage::put(NEXT_SESSION_LENGTH, &new);
+	}
+
+	/// Forces a new session.
+	pub fn force_new_session() {
+		rotate_session();
+	}
+}
+
+// INTERNAL API (available to other runtime modules)
+
+pub mod internal {
+	use super::*;
+
+	/// Set the current set of validators.
+	///
+	/// Called by staking::next_era() only. `next_session` should be called after this in order to
+	/// update the session keys to the next validator set.
+	pub fn set_validators(new: &[AccountId]) {
+		ValidatorStorageVec::set_items(new);
+		consensus::internal::set_authorities(new);
+	}
+
+	/// Hook to be called after transaction processing.
+	pub fn check_rotate_session() {
+		// do this last, after the staking system has had chance to switch out the authorities for the
+		// new set.
+		// check block number and call next_session if necessary.
+		if (system::block_number() - last_length_change()) % length() == 0 {
+			rotate_session();
+		}
+	}
+}
+
+/// Move onto next session: register the new authority set.
+fn rotate_session() {
+	// Increment current session index.
+	storage::put(CURRENT_INDEX, &(current_index() + 1));
+
+	// Enact era length change.
+	if let Some(next_len) = storage::get::<u64>(NEXT_SESSION_LENGTH) {
+		storage::put(SESSION_LENGTH, &next_len);
+		storage::put(LAST_LENGTH_CHANGE, &system::block_number());
+		storage::kill(NEXT_SESSION_LENGTH);
+	}
+
+	// Update any changes in session keys.
+	validators().iter().enumerate().for_each(|(i, v)| {
+		let k = v.to_keyed_vec(NEXT_KEY_FOR);
+		if let Some(n) = storage::take(&k) {
+			consensus::internal::set_authority(i as u32, &n);
+		}
+	});
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::public::*;
+	use super::privileged::*;
+	use super::internal::*;
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{KeyedVec, Joiner};
+	use keyring::Keyring;
+	use environment::with_env;
+	use demo_primitives::AccountId;
+	use runtime::{consensus, session};
+
+	fn simple_setup() -> TestExternalities {
+		map![
+			twox_128(SESSION_LENGTH).to_vec() => vec![].and(&2u64),
+			// the validators (10, 20, ...)
+			twox_128(b"ses:val:len").to_vec() => vec![].and(&2u32),
+			twox_128(&0u32.to_keyed_vec(ValidatorStorageVec::PREFIX)).to_vec() => vec![10; 32],
+			twox_128(&1u32.to_keyed_vec(ValidatorStorageVec::PREFIX)).to_vec() => vec![20; 32],
+			// initial session keys (11, 21, ...)
+			b":auth:len".to_vec() => vec![].and(&2u32),
+			0u32.to_keyed_vec(b":auth:") => vec![11; 32],
+			1u32.to_keyed_vec(b":auth:") => vec![21; 32]
+		]
+	}
+
+	#[test]
+	fn simple_setup_should_work() {
+		let mut t = simple_setup();
+		with_externalities(&mut t, || {
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [21u8; 32]]);
+			assert_eq!(length(), 2u64);
+			assert_eq!(validators(), vec![[10u8; 32], [20u8; 32]]);
+		});
+	}
+
+	#[test]
+	fn session_length_change_should_work() {
+		let mut t = simple_setup();
+		with_externalities(&mut t, || {
+			// Block 1: Change to length 3; no visible change.
+			with_env(|e| e.block_number = 1);
+			set_length(3);
+			check_rotate_session();
+			assert_eq!(length(), 2);
+			assert_eq!(current_index(), 0);
+
+			// Block 2: Length now changed to 3. Index incremented.
+			with_env(|e| e.block_number = 2);
+			set_length(3);
+			check_rotate_session();
+			assert_eq!(length(), 3);
+			assert_eq!(current_index(), 1);
+
+			// Block 3: Length now changed to 3. Index incremented.
+			with_env(|e| e.block_number = 3);
+			check_rotate_session();
+			assert_eq!(length(), 3);
+			assert_eq!(current_index(), 1);
+
+			// Block 4: Change to length 2; no visible change.
+			with_env(|e| e.block_number = 4);
+			set_length(2);
+			check_rotate_session();
+			assert_eq!(length(), 3);
+			assert_eq!(current_index(), 1);
+
+			// Block 5: Length now changed to 2. Index incremented.
+			with_env(|e| e.block_number = 5);
+			check_rotate_session();
+			assert_eq!(length(), 2);
+			assert_eq!(current_index(), 2);
+
+			// Block 6: No change.
+			with_env(|e| e.block_number = 6);
+			check_rotate_session();
+			assert_eq!(length(), 2);
+			assert_eq!(current_index(), 2);
+
+			// Block 7: Next index.
+			with_env(|e| e.block_number = 7);
+			check_rotate_session();
+			assert_eq!(length(), 2);
+			assert_eq!(current_index(), 3);
+		});
+	}
+
+	#[test]
+	fn session_change_should_work() {
+		let mut t = simple_setup();
+		with_externalities(&mut t, || {
+			// Block 1: No change
+			with_env(|e| e.block_number = 1);
+			check_rotate_session();
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [21u8; 32]]);
+
+			// Block 2: Session rollover, but no change.
+			with_env(|e| e.block_number = 2);
+			check_rotate_session();
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [21u8; 32]]);
+
+			// Block 3: Set new key for validator 2; no visible change.
+			with_env(|e| e.block_number = 3);
+			set_key(&[20; 32], &[22; 32]);
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [21u8; 32]]);
+
+			check_rotate_session();
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [21u8; 32]]);
+
+			// Block 4: Session rollover, authority 2 changes.
+			with_env(|e| e.block_number = 4);
+			check_rotate_session();
+			assert_eq!(consensus::authorities(), vec![[11u8; 32], [22u8; 32]]);
+		});
+	}
+}

substrate/demo/runtime/src/runtime/staking.rs

@@ -0,0 +1,407 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Staking manager: Handles balances and periodically determines the best set of validators.
+
+use rstd::prelude::*;
+use rstd::cell::RefCell;
+use runtime_io::print;
+use codec::KeyedVec;
+use runtime_support::{storage, StorageVec};
+use demo_primitives::{BlockNumber, AccountId};
+use runtime::{system, session, governance};
+
+/// The balance of an account.
+pub type Balance = u64;
+
+/// The amount of bonding period left in an account. Measured in eras.
+pub type Bondage = u64;
+
+struct IntentionStorageVec {}
+impl StorageVec for IntentionStorageVec {
+	type Item = AccountId;
+	const PREFIX: &'static[u8] = b"sta:wil:";
+}
+
+const BONDING_DURATION: &[u8] = b"sta:loc";
+const VALIDATOR_COUNT: &[u8] = b"sta:vac";
+const SESSIONS_PER_ERA: &[u8] = b"sta:spe";
+const NEXT_SESSIONS_PER_ERA: &[u8] = b"sta:nse";
+const CURRENT_ERA: &[u8] = b"sta:era";
+const LAST_ERA_LENGTH_CHANGE: &[u8] = b"sta:lec";
+const BALANCE_OF: &[u8] = b"sta:bal:";
+const BONDAGE_OF: &[u8] = b"sta:bon:";
+
+/// The length of the bonding duration in eras.
+pub fn bonding_duration() -> BlockNumber {
+	storage::get_or_default(BONDING_DURATION)
+}
+
+/// The length of a staking era in sessions.
+pub fn validator_count() -> usize {
+	storage::get_or_default::<u32>(VALIDATOR_COUNT) as usize
+}
+
+/// The length of a staking era in blocks.
+pub fn era_length() -> BlockNumber {
+	sessions_per_era() * session::length()
+}
+
+/// The length of a staking era in sessions.
+pub fn sessions_per_era() -> BlockNumber {
+	storage::get_or_default(SESSIONS_PER_ERA)
+}
+
+/// The current era index.
+pub fn current_era() -> BlockNumber {
+	storage::get_or_default(CURRENT_ERA)
+}
+
+/// The block number at which the era length last changed.
+pub fn last_era_length_change() -> BlockNumber {
+	storage::get_or_default(LAST_ERA_LENGTH_CHANGE)
+}
+
+/// The balance of a given account.
+pub fn balance(who: &AccountId) -> Balance {
+	storage::get_or_default(&who.to_keyed_vec(BALANCE_OF))
+}
+
+/// The liquidity-state of a given account.
+pub fn bondage(who: &AccountId) -> Bondage {
+	storage::get_or_default(&who.to_keyed_vec(BONDAGE_OF))
+}
+
+// Each identity's stake may be in one of three bondage states, given by an integer:
+// - n | n <= current_era(): inactive: free to be transferred.
+// - ~0: active: currently representing a validator.
+// - n | n > current_era(): deactivating: recently representing a validator and not yet
+//   ready for transfer.
+
+pub mod public {
+	use super::*;
+
+	/// Transfer some unlocked staking balance to another staker.
+	pub fn transfer(transactor: &AccountId, dest: &AccountId, value: Balance) {
+		let from_key = transactor.to_keyed_vec(BALANCE_OF);
+		let from_balance = storage::get_or_default::<Balance>(&from_key);
+		assert!(from_balance >= value);
+		let to_key = dest.to_keyed_vec(BALANCE_OF);
+		let to_balance: Balance = storage::get_or_default(&to_key);
+		assert!(bondage(transactor) <= bondage(dest));
+		assert!(to_balance + value > to_balance);	// no overflow
+		storage::put(&from_key, &(from_balance - value));
+		storage::put(&to_key, &(to_balance + value));
+	}
+
+	/// Declare the desire to stake for the transactor.
+	///
+	/// Effects will be felt at the beginning of the next era.
+	pub fn stake(transactor: &AccountId) {
+		let mut intentions = IntentionStorageVec::items();
+		// can't be in the list twice.
+		assert!(intentions.iter().find(|t| *t == transactor).is_none(), "Cannot stake if already staked.");
+		intentions.push(transactor.clone());
+		IntentionStorageVec::set_items(&intentions);
+		storage::put(&transactor.to_keyed_vec(BONDAGE_OF), &u64::max_value());
+	}
+
+	/// Retract the desire to stake for the transactor.
+	///
+	/// Effects will be felt at the beginning of the next era.
+	pub fn unstake(transactor: &AccountId) {
+		let mut intentions = IntentionStorageVec::items();
+		if let Some(position) = intentions.iter().position(|t| t == transactor) {
+			intentions.swap_remove(position);
+		} else {
+			panic!("Cannot unstake if not already staked.");
+		}
+		IntentionStorageVec::set_items(&intentions);
+		storage::put(&transactor.to_keyed_vec(BONDAGE_OF), &(current_era() + bonding_duration()));
+	}
+}
+
+pub mod privileged {
+	use super::*;
+
+	/// Set the number of sessions in an era.
+	pub fn set_sessions_per_era(new: BlockNumber) {
+		storage::put(NEXT_SESSIONS_PER_ERA, &new);
+	}
+
+	/// The length of the bonding duration in eras.
+	pub fn set_bonding_duration(new: BlockNumber) {
+		storage::put(BONDING_DURATION, &new);
+	}
+
+	/// The length of a staking era in sessions.
+	pub fn set_validator_count(new: u32) {
+		storage::put(VALIDATOR_COUNT, &new);
+	}
+
+	/// Force there to be a new era. This also forces a new session immediately after.
+	pub fn force_new_era() {
+		new_era();
+		session::privileged::force_new_session();
+	}
+}
+
+pub mod internal {
+	use super::*;
+
+	/// Hook to be called after to transaction processing.
+	pub fn check_new_era() {
+		// check block number and call new_era if necessary.
+		if (system::block_number() - last_era_length_change()) % era_length() == 0 {
+			new_era();
+		}
+	}
+}
+
+/// The era has changed - enact new staking set.
+///
+/// NOTE: This always happens immediately before a session change to ensure that new validators
+/// get a chance to set their session keys.
+fn new_era() {
+	// Inform governance module that it's the end of an era
+	governance::internal::end_of_an_era();
+
+	// Increment current era.
+	storage::put(CURRENT_ERA, &(current_era() + 1));
+
+	// Enact era length change.
+	let next_spe: u64 = storage::get_or_default(NEXT_SESSIONS_PER_ERA);
+	if next_spe > 0 && next_spe != sessions_per_era() {
+		storage::put(SESSIONS_PER_ERA, &next_spe);
+		storage::put(LAST_ERA_LENGTH_CHANGE, &system::block_number());
+	}
+
+	// evaluate desired staking amounts and nominations and optimise to find the best
+	// combination of validators, then use session::internal::set_validators().
+	// for now, this just orders would-be stakers by their balances and chooses the top-most
+	// validator_count() of them.
+	let mut intentions = IntentionStorageVec::items()
+		.into_iter()
+		.map(|v| (balance(&v), v))
+		.collect::<Vec<_>>();
+	intentions.sort_unstable_by(|&(b1, _), &(b2, _)| b2.cmp(&b1));
+	session::internal::set_validators(
+		&intentions.into_iter()
+			.map(|(_, v)| v)
+			.take(validator_count())
+			.collect::<Vec<_>>()
+	);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::internal::*;
+	use super::public::*;
+	use super::privileged::*;
+
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{KeyedVec, Joiner};
+	use keyring::Keyring;
+	use environment::with_env;
+	use demo_primitives::AccountId;
+	use runtime::{staking, session};
+
+	#[test]
+	fn staking_should_work() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+		let four = [4u8; 32];
+
+		let mut t: TestExternalities = map![
+			twox_128(b"ses:len").to_vec() => vec![].and(&1u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].and(&2u32),
+			twox_128(&0u32.to_keyed_vec(b"ses:val:")).to_vec() => vec![10; 32],
+			twox_128(&1u32.to_keyed_vec(b"ses:val:")).to_vec() => vec![20; 32],
+			twox_128(SESSIONS_PER_ERA).to_vec() => vec![].and(&2u64),
+			twox_128(VALIDATOR_COUNT).to_vec() => vec![].and(&2u32),
+			twox_128(BONDING_DURATION).to_vec() => vec![].and(&3u64),
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&10u64),
+			twox_128(&two.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&20u64),
+			twox_128(&three.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&30u64),
+			twox_128(&four.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&40u64)
+		];
+
+		with_externalities(&mut t, || {
+			assert_eq!(era_length(), 2u64);
+			assert_eq!(validator_count(), 2usize);
+			assert_eq!(bonding_duration(), 3u64);
+			assert_eq!(session::validators(), vec![[10u8; 32], [20u8; 32]]);
+
+			// Block 1: Add three validators. No obvious change.
+			with_env(|e| e.block_number = 1);
+			stake(&one);
+			stake(&two);
+			stake(&four);
+			check_new_era();
+			assert_eq!(session::validators(), vec![[10u8; 32], [20u8; 32]]);
+
+			// Block 2: New validator set now.
+			with_env(|e| e.block_number = 2);
+			check_new_era();
+			assert_eq!(session::validators(), vec![four.clone(), two.clone()]);
+
+			// Block 3: Unstake highest, introduce another staker. No change yet.
+			with_env(|e| e.block_number = 3);
+			stake(&three);
+			unstake(&four);
+			check_new_era();
+
+			// Block 4: New era - validators change.
+			with_env(|e| e.block_number = 4);
+			check_new_era();
+			assert_eq!(session::validators(), vec![three.clone(), two.clone()]);
+
+			// Block 5: Transfer stake from highest to lowest. No change yet.
+			with_env(|e| e.block_number = 5);
+			transfer(&four, &one, 40);
+			check_new_era();
+
+			// Block 6: Lowest now validator.
+			with_env(|e| e.block_number = 6);
+			check_new_era();
+			assert_eq!(session::validators(), vec![one.clone(), three.clone()]);
+
+			// Block 7: Unstake three. No change yet.
+			with_env(|e| e.block_number = 7);
+			unstake(&three);
+			check_new_era();
+			assert_eq!(session::validators(), vec![one.clone(), three.clone()]);
+
+			// Block 8: Back to one and two.
+			with_env(|e| e.block_number = 8);
+			check_new_era();
+			assert_eq!(session::validators(), vec![one.clone(), two.clone()]);
+		});
+	}
+
+	#[test]
+	fn staking_eras_work() {
+		let mut t: TestExternalities = map![
+			twox_128(b"ses:len").to_vec() => vec![].and(&1u64),
+			twox_128(SESSIONS_PER_ERA).to_vec() => vec![].and(&2u64)
+		];
+		with_externalities(&mut t, || {
+			assert_eq!(era_length(), 2u64);
+			assert_eq!(sessions_per_era(), 2u64);
+			assert_eq!(last_era_length_change(), 0u64);
+			assert_eq!(current_era(), 0u64);
+
+			// Block 1: No change.
+			with_env(|e| e.block_number = 1);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 2u64);
+			assert_eq!(last_era_length_change(), 0u64);
+			assert_eq!(current_era(), 0u64);
+
+			// Block 2: Simple era change.
+			with_env(|e| e.block_number = 2);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 2u64);
+			assert_eq!(last_era_length_change(), 0u64);
+			assert_eq!(current_era(), 1u64);
+
+			// Block 3: Schedule an era length change; no visible changes.
+			with_env(|e| e.block_number = 3);
+			set_sessions_per_era(3);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 2u64);
+			assert_eq!(last_era_length_change(), 0u64);
+			assert_eq!(current_era(), 1u64);
+
+			// Block 4: Era change kicks in.
+			with_env(|e| e.block_number = 4);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 3u64);
+			assert_eq!(last_era_length_change(), 4u64);
+			assert_eq!(current_era(), 2u64);
+
+			// Block 5: No change.
+			with_env(|e| e.block_number = 5);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 3u64);
+			assert_eq!(last_era_length_change(), 4u64);
+			assert_eq!(current_era(), 2u64);
+
+			// Block 6: No change.
+			with_env(|e| e.block_number = 6);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 3u64);
+			assert_eq!(last_era_length_change(), 4u64);
+			assert_eq!(current_era(), 2u64);
+
+			// Block 7: Era increment.
+			with_env(|e| e.block_number = 7);
+			check_new_era();
+			assert_eq!(sessions_per_era(), 3u64);
+			assert_eq!(last_era_length_change(), 4u64);
+			assert_eq!(current_era(), 3u64);
+		});
+	}
+
+	#[test]
+	fn staking_balance_works() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&42u64)
+		];
+
+		with_externalities(&mut t, || {
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 0);
+		});
+	}
+
+	#[test]
+	fn staking_balance_transfer_works() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&111u64)
+		];
+
+		with_externalities(&mut t, || {
+			transfer(&one, &two, 69);
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 69);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn staking_balance_transfer_when_bonded_doesnt_work() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].and(&111u64)
+		];
+
+		with_externalities(&mut t, || {
+			stake(&one);
+			transfer(&one, &two, 69);
+		});
+	}
+}

substrate/demo/runtime/src/runtime/system.rs

@@ -0,0 +1,370 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! System manager: Handles all of the top-level stuff; executing block/transaction, setting code
+//! and depositing logs.
+
+use rstd::prelude::*;
+use rstd::mem;
+use runtime_io::{print, storage_root, enumerated_trie_root};
+use codec::{KeyedVec, Slicable};
+use runtime_support::{Hashable, storage};
+use environment::with_env;
+use demo_primitives::{AccountId, Hash, TxOrder, BlockNumber, Block, Header,
+	UncheckedTransaction, Function, Log};
+use runtime::{staking, session};
+
+const NONCE_OF: &[u8] = b"sys:non:";
+const BLOCK_HASH_AT: &[u8] = b"sys:old:";
+const CODE: &[u8] = b"sys:cod";
+
+/// The current block number being processed. Set by `execute_block`.
+pub fn block_number() -> BlockNumber {
+	with_env(|e| e.block_number)
+}
+
+/// Get the block hash of a given block (uses storage).
+pub fn block_hash(number: BlockNumber) -> Hash {
+	storage::get_or_default(&number.to_keyed_vec(BLOCK_HASH_AT))
+}
+
+pub mod privileged {
+	use super::*;
+
+	/// Set the new code.
+	pub fn set_code(new: &[u8]) {
+		storage::unhashed::put_raw(b":code", new);
+	}
+}
+
+pub mod internal {
+	use super::*;
+
+	struct CheckedTransaction(UncheckedTransaction);
+
+	/// Deposits a log and ensures it matches the blocks log data.
+	pub fn deposit_log(log: Log) {
+		with_env(|e| e.digest.logs.push(log));
+	}
+
+	/// Actually execute all transitioning for `block`.
+	pub fn execute_block(mut block: Block) {
+		// populate environment from header.
+		with_env(|e| {
+			e.block_number = block.header.number;
+			e.parent_hash = block.header.parent_hash;
+		});
+
+		// any initial checks
+		initial_checks(&block);
+
+		// execute transactions
+		block.transactions.iter().cloned().for_each(super::execute_transaction);
+
+		// post-transactional book-keeping.
+		staking::internal::check_new_era();
+		session::internal::check_rotate_session();
+
+		// any final checks
+		final_checks(&block);
+
+		// any stuff that we do after taking the storage root.
+		post_finalise(&block.header);
+	}
+
+	/// Execute a transaction outside of the block execution function.
+	/// This doesn't attempt to validate anything regarding the block.
+	pub fn execute_transaction(utx: UncheckedTransaction, mut header: Header) -> Header {
+		// populate environment from header.
+		with_env(|e| {
+			e.block_number = header.number;
+			e.parent_hash = header.parent_hash;
+			mem::swap(&mut header.digest, &mut e.digest);
+		});
+
+		super::execute_transaction(utx);
+
+		with_env(|e| {
+			mem::swap(&mut header.digest, &mut e.digest);
+		});
+		header
+	}
+
+	/// Finalise the block - it is up the caller to ensure that all header fields are valid
+	/// except state-root.
+	pub fn finalise_block(mut header: Header) -> Header {
+		// populate environment from header.
+		with_env(|e| {
+			e.block_number = header.number;
+			e.parent_hash = header.parent_hash;
+			mem::swap(&mut header.digest, &mut e.digest);
+		});
+
+		staking::internal::check_new_era();
+		session::internal::check_rotate_session();
+
+		header.state_root = storage_root().into();
+		with_env(|e| {
+			mem::swap(&mut header.digest, &mut e.digest);
+		});
+
+		post_finalise(&header);
+
+		header
+	}
+
+	/// Dispatch a function.
+	pub fn dispatch_function(function: &Function, transactor: &AccountId) {
+		match *function {
+			Function::StakingStake => {
+				::runtime::staking::public::stake(transactor);
+			}
+			Function::StakingUnstake => {
+				::runtime::staking::public::unstake(transactor);
+			}
+			Function::StakingTransfer(dest, value) => {
+				::runtime::staking::public::transfer(transactor, &dest, value);
+			}
+			Function::SessionSetKey(session) => {
+				::runtime::session::public::set_key(transactor, &session);
+			}
+			Function::TimestampSet(t) => {
+				::runtime::timestamp::public::set(t);
+			}
+			Function::GovernancePropose(ref proposal) => {
+				::runtime::governance::public::propose(transactor, proposal);
+			}
+			Function::GovernanceApprove(era_index) => {
+				::runtime::governance::public::approve(transactor, era_index);
+			}
+		}
+	}
+}
+
+fn execute_transaction(utx: UncheckedTransaction) {
+	use ::transaction;
+
+	// Verify the signature is good.
+	let tx = match transaction::check(utx) {
+		Ok(tx) => tx,
+		Err(_) => panic!("All transactions should be properly signed"),
+	};
+
+	// check nonce
+	let nonce_key = tx.signed.to_keyed_vec(NONCE_OF);
+	let expected_nonce: TxOrder = storage::get_or(&nonce_key, 0);
+	assert!(tx.nonce == expected_nonce, "All transactions should have the correct nonce");
+
+	// increment nonce in storage
+	storage::put(&nonce_key, &(expected_nonce + 1));
+
+	// decode parameters and dispatch
+	internal::dispatch_function(&tx.function, &tx.signed);
+}
+
+fn initial_checks(block: &Block) {
+	let ref header = block.header;
+
+	// check parent_hash is correct.
+	assert!(
+		header.number > 0 && block_hash(header.number - 1) == header.parent_hash,
+		"Parent hash should be valid."
+	);
+
+	// check transaction trie root represents the transactions.
+	let txs = block.transactions.iter().map(Slicable::encode).collect::<Vec<_>>();
+	let txs = txs.iter().map(Vec::as_slice).collect::<Vec<_>>();
+	let txs_root = enumerated_trie_root(&txs).into();
+	info_expect_equal_hash(&header.transaction_root, &txs_root);
+	assert!(header.transaction_root == txs_root, "Transaction trie root must be valid.");
+}
+
+fn final_checks(block: &Block) {
+	let ref header = block.header;
+
+	// check digest
+	with_env(|e| {
+		assert!(header.digest == e.digest);
+	});
+
+	// check storage root.
+	let storage_root = storage_root().into();
+	info_expect_equal_hash(&header.state_root, &storage_root);
+	assert!(header.state_root == storage_root, "Storage root must match that calculated.");
+}
+
+fn post_finalise(header: &Header) {
+	// store the header hash in storage; we can't do it before otherwise there would be a
+	// cyclic dependency.
+	storage::put(&header.number.to_keyed_vec(BLOCK_HASH_AT), &header.blake2_256());
+}
+
+#[cfg(feature = "std")]
+fn info_expect_equal_hash(given: &Hash, expected: &Hash) {
+	use primitives::hexdisplay::HexDisplay;
+	if given != expected {
+		println!("Hash: given={}, expected={}", HexDisplay::from(&given.0), HexDisplay::from(&expected.0));
+	}
+}
+
+#[cfg(not(feature = "std"))]
+fn info_expect_equal_hash(given: &Hash, expected: &Hash) {
+	if given != expected {
+		print("Hash not equal");
+		print(&given.0[..]);
+		print(&expected.0[..]);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::internal::*;
+
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{Joiner, KeyedVec, Slicable};
+	use keyring::Keyring;
+	use environment::with_env;
+	use primitives::hexdisplay::HexDisplay;
+	use demo_primitives::{Header, Digest, UncheckedTransaction, Transaction, Function};
+	use runtime::staking;
+
+	#[test]
+	fn staking_balance_transfer_dispatch_works() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t: TestExternalities = map![
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		];
+
+		let tx = UncheckedTransaction {
+			transaction: Transaction {
+				signed: one.clone(),
+				nonce: 0,
+				function: Function::StakingTransfer(two, 69),
+			},
+			signature: hex!("5f9832c5a4a39e2dd4a3a0c5b400e9836beb362cb8f7d845a8291a2ae6fe366612e080e4acd0b5a75c3d0b6ee69614a68fb63698c1e76bf1f2dcd8fa617ddf05").into(),
+		};
+
+		with_externalities(&mut t, || {
+			internal::execute_transaction(tx, Header::from_block_number(1));
+			assert_eq!(staking::balance(&one), 42);
+			assert_eq!(staking::balance(&two), 69);
+		});
+	}
+
+	fn new_test_ext() -> TestExternalities {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+		let three = [3u8; 32];
+
+		map![
+			twox_128(&0u64.to_keyed_vec(b"sys:old:")).to_vec() => [69u8; 32].encode(),
+			twox_128(b"gov:apr").to_vec() => vec![].and(&667u32),
+			twox_128(b"ses:len").to_vec() => vec![].and(&2u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"ses:val:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"ses:val:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"ses:val:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:wil:len").to_vec() => vec![].and(&3u32),
+			twox_128(&0u32.to_keyed_vec(b"sta:wil:")).to_vec() => one.to_vec(),
+			twox_128(&1u32.to_keyed_vec(b"sta:wil:")).to_vec() => two.to_vec(),
+			twox_128(&2u32.to_keyed_vec(b"sta:wil:")).to_vec() => three.to_vec(),
+			twox_128(b"sta:spe").to_vec() => vec![].and(&2u64),
+			twox_128(b"sta:vac").to_vec() => vec![].and(&3u64),
+			twox_128(b"sta:era").to_vec() => vec![].and(&0u64),
+			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
+		]
+	}
+
+	#[test]
+	fn block_import_works() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t = new_test_ext();
+
+		let h = Header {
+			parent_hash: [69u8; 32].into(),
+			number: 1,
+			state_root: hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0").into(),
+			transaction_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+			digest: Digest { logs: vec![], },
+		};
+
+		let b = Block {
+			header: h,
+			transactions: vec![],
+		};
+
+		with_externalities(&mut t, || {
+			execute_block(b);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn block_import_of_bad_state_root_fails() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t = new_test_ext();
+
+		let h = Header {
+			parent_hash: [69u8; 32].into(),
+			number: 1,
+			state_root: [0u8; 32].into(),
+			transaction_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
+			digest: Digest { logs: vec![], },
+		};
+
+		let b = Block {
+			header: h,
+			transactions: vec![],
+		};
+
+		with_externalities(&mut t, || {
+			execute_block(b);
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn block_import_of_bad_transaction_root_fails() {
+		let one = Keyring::One.to_raw_public();
+		let two = Keyring::Two.to_raw_public();
+
+		let mut t = new_test_ext();
+
+		let h = Header {
+			parent_hash: [69u8; 32].into(),
+			number: 1,
+			state_root: hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0").into(),
+			transaction_root: [0u8; 32].into(),
+			digest: Digest { logs: vec![], },
+		};
+
+		let b = Block {
+			header: h,
+			transactions: vec![],
+		};
+
+		with_externalities(&mut t, || {
+			execute_block(b);
+		});
+	}
+}

substrate/demo/runtime/src/runtime/timestamp.rs

@@ -0,0 +1,60 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Substrate Demo.
+
+// Substrate Demo 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 Demo 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 Demo.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Timestamp manager: just handles the current timestamp.
+
+use runtime_support::storage;
+
+pub type Timestamp = u64;
+
+const CURRENT_TIMESTAMP: &[u8] = b"tim:val";
+
+/// Get the current time.
+pub fn get() -> Timestamp {
+	storage::get_or_default(CURRENT_TIMESTAMP)
+}
+
+pub mod public {
+	use super::*;
+
+	/// Set the current time.
+	pub fn set(now: Timestamp) {
+		storage::put(CURRENT_TIMESTAMP, &now);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::public::*;
+
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use runtime::timestamp;
+	use codec::{Joiner, KeyedVec};
+
+	#[test]
+	fn timestamp_works() {
+		let mut t: TestExternalities = map![
+			twox_128(CURRENT_TIMESTAMP).to_vec() => vec![].and(&42u64)
+		];
+
+		with_externalities(&mut t, || {
+			assert_eq!(get(), 42);
+			set(69);
+			assert_eq!(get(), 69);
+		});
+	}
+}

substrate/demo/runtime/wasm/Cargo.lock

@@ -0,0 +1,893 @@
+[[package]]
+name = "aho-corasick"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ansi_term"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "arrayvec"
+version = "0.3.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "odds 0.2.26 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "bigint"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "blake2-rfc"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cc"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "coco"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "either 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "crunchy"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "demo-primitives"
+version = "0.1.0"
+dependencies = [
+ "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-std 0.1.0",
+]
+
+[[package]]
+name = "demo-runtime"
+version = "0.1.0"
+dependencies = [
+ "demo-primitives 0.1.0",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-io 0.1.0",
+ "substrate-runtime-std 0.1.0",
+ "substrate-runtime-support 0.1.0",
+]
+
+[[package]]
+name = "ed25519"
+version = "0.1.0"
+dependencies = [
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-primitives 0.1.0",
+ "untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "either"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "elastic-array"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "environmental"
+version = "0.1.0"
+
+[[package]]
+name = "ethcore-bigint"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "plain_hasher 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "ethcore-bytes"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ethcore-logger"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "arrayvec 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)",
+ "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "isatty 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fixed-hash"
+version = "0.1.3"
+source = "git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm#8dc457899afdaf968ff7f16140b03d1e37b01d71"
+dependencies = [
+ "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "gcc"
+version = "0.3.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "hashdb"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "elastic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "heapsize"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hex-literal"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "hex-literal-impl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro-hack 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "hex-literal-impl"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro-hack 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "isatty"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "keccak-hash"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "tiny-keccak 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lazy_static"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "lazy_static"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "libc"
+version = "0.2.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "log"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "memchr"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "memorydb"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "elastic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hashdb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "keccak-hash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "nodrop"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "num_cpus"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "odds"
+version = "0.2.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "owning_ref"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "parking_lot_core 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "patricia-trie"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "elastic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bytes 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-logger 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hashdb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "keccak-hash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memorydb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "plain_hasher"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "proc-macro-hack-impl 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "proc-macro-hack-impl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "pwasm-alloc"
+version = "0.1.0"
+dependencies = [
+ "pwasm-libc 0.1.0",
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "pwasm-libc"
+version = "0.1.0"
+
+[[package]]
+name = "quote"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rand"
+version = "0.3.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rand"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rayon"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rayon-core 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "coco 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "redox_termios"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "regex"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "aho-corasick 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "ring"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rayon 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rlp"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "elastic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "rustc-hex"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "rustc-hex"
+version = "2.0.0"
+source = "git+https://github.com/rphmeier/rustc-hex.git#ee2ec40b9062ac7769ccb9dc891d6dc2cc9009d7"
+
+[[package]]
+name = "rustc_version"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "scopeguard"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "semver"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "serde"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "serde_derive"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive_internals 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "smallvec"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "substrate-codec"
+version = "0.1.0"
+dependencies = [
+ "substrate-runtime-std 0.1.0",
+]
+
+[[package]]
+name = "substrate-primitives"
+version = "0.1.0"
+dependencies = [
+ "blake2-rfc 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)",
+ "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fixed-hash 0.1.3 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)",
+ "rustc-hex 2.0.0 (git+https://github.com/rphmeier/rustc-hex.git)",
+ "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-runtime-std 0.1.0",
+ "twox-hash 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "uint 0.1.2 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)",
+]
+
+[[package]]
+name = "substrate-runtime-io"
+version = "0.1.0"
+dependencies = [
+ "ed25519 0.1.0",
+ "environmental 0.1.0",
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-std 0.1.0",
+ "substrate-state-machine 0.1.0",
+ "triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "substrate-runtime-std"
+version = "0.1.0"
+dependencies = [
+ "pwasm-alloc 0.1.0",
+ "pwasm-libc 0.1.0",
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "substrate-runtime-support"
+version = "0.1.0"
+dependencies = [
+ "ed25519 0.1.0",
+ "environmental 0.1.0",
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-runtime-io 0.1.0",
+ "substrate-runtime-std 0.1.0",
+]
+
+[[package]]
+name = "substrate-state-machine"
+version = "0.1.0"
+dependencies = [
+ "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hashdb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memorydb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "patricia-trie 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "substrate-primitives 0.1.0",
+ "triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "syn"
+version = "0.11.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "synom"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "termion"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "thread_local"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "time"
+version = "0.1.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)",
+ "redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "triehash"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "keccak-hash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rlp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "uint"
+version = "0.1.2"
+source = "git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm#8dc457899afdaf968ff7f16140b03d1e37b01d71"
+dependencies = [
+ "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "unreachable"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "untrusted"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "utf8-ranges"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[metadata]
+"checksum aho-corasick 0.6.4 (registry+https://github.com/rust-lang/crates.io-index)" = "d6531d44de723825aa81398a6415283229725a00fa30713812ab9323faa82fc4"
+"checksum ansi_term 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "23ac7c30002a5accbf7e8987d0632fa6de155b7c3d39d0067317a391e00a2ef6"
+"checksum arrayvec 0.3.25 (registry+https://github.com/rust-lang/crates.io-index)" = "06f59fe10306bb78facd90d28c2038ad23ffaaefa85bac43c8a434cde383334f"
+"checksum arrayvec 0.4.7 (registry+https://github.com/rust-lang/crates.io-index)" = "a1e964f9e24d588183fcb43503abda40d288c8657dfc27311516ce2f05675aef"
+"checksum bigint 4.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5442186ef6560f30f1ee4b9c1e4c87a35a6879d3644550cc248ec2b955eb5fcd"
+"checksum bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b3c30d3802dfb7281680d6285f2ccdaa8c2d8fee41f93805dba5c4cf50dc23cf"
+"checksum blake2-rfc 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "5d6d530bdd2d52966a6d03b7a964add7ae1a288d25214066fd4b600f0f796400"
+"checksum byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "652805b7e73fada9d85e9a6682a4abd490cb52d96aeecc12e33a0de34dfd0d23"
+"checksum cc 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "deaf9ec656256bb25b404c51ef50097207b9cbb29c933d31f92cae5a8a0ffee0"
+"checksum cfg-if 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d4c819a1287eb618df47cc647173c5c4c66ba19d888a6e50d605672aed3140de"
+"checksum coco 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c06169f5beb7e31c7c67ebf5540b8b472d23e3eade3b2ec7d1f5b504a85f91bd"
+"checksum constant_time_eq 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8ff012e225ce166d4422e0e78419d901719760f62ae2b7969ca6b564d1b54a9e"
+"checksum crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "a2f4a431c5c9f662e1200b7c7f02c34e91361150e382089a8f2dec3ba680cbda"
+"checksum either 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "740178ddf48b1a9e878e6d6509a1442a2d42fd2928aae8e7a6f8a36fb01981b3"
+"checksum elastic-array 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "258ff6a9a94f648d0379dbd79110e057edbb53eb85cc237e33eadf8e5a30df85"
+"checksum env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3ddf21e73e016298f5cb37d6ef8e8da8e39f91f9ec8b0df44b7deb16a9f8cd5b"
+"checksum ethcore-bigint 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcb5af77e74a8f70e9c3337e069c37bc82178ef1b459c02091f73c4ad5281eb5"
+"checksum ethcore-bytes 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3977c772cd6c5c22e1c7cfa208e4c3b746bd6c3a6c8eeec0999a6b2103015ad5"
+"checksum ethcore-logger 1.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1fd5813e49546030be7d134e775088d56b8ff4ab60617b90e93d4f0513da4c5b"
+"checksum fixed-hash 0.1.3 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)" = "<none>"
+"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+"checksum gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)" = "5e33ec290da0d127825013597dbdfc28bee4964690c7ce1166cbc2a7bd08b1bb"
+"checksum hashdb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d97be07c358c5b461268b4ce60304024c5fa5acfd4bd8cd743639f0252003cf5"
+"checksum heapsize 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1679e6ea370dee694f91f1dc469bf94cf8f52051d147aec3e1f9497c6fc22461"
+"checksum hex-literal 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd546ef520ab3745f1aae5f2cdc6de9e6498e94d1ab138b9eb3ddfbf335847fb"
+"checksum hex-literal-impl 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2ea76da4c7f1a54d01d54985566d3fdd960b2bbd7b970da024821c883c2d9631"
+"checksum isatty 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)" = "8f2a233726c7bb76995cec749d59582e5664823b7245d4970354408f1d79a7a2"
+"checksum keccak-hash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1f300c1f149cd9ca5214eed24f6e713a597517420fb8b15499824aa916259ec1"
+"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
+"checksum lazy_static 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c8f31047daa365f19be14b47c29df4f7c3b581832407daabe6ae77397619237d"
+"checksum libc 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "1e5d97d6708edaa407429faa671b942dc0f2727222fb6b6539bf1db936e4b121"
+"checksum log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+"checksum log 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "89f010e843f2b1a31dbd316b3b8d443758bc634bed37aabade59c686d644e0a2"
+"checksum memchr 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "796fba70e76612589ed2ce7f45282f5af869e0fdd7cc6199fa1aa1f1d591ba9d"
+"checksum memorydb 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "013b7e4c5e10c764936ebc6bd3662d8e3c92292d267bf6a42ef3f5cad9c793ee"
+"checksum nodrop 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9a2228dca57108069a5262f2ed8bd2e82496d2e074a06d1ccc7ce1687b6ae0a2"
+"checksum num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c51a3322e4bca9d212ad9a158a02abc6934d005490c054a2778df73a70aa0a30"
+"checksum odds 0.2.26 (registry+https://github.com/rust-lang/crates.io-index)" = "4eae0151b9dacf24fcc170d9995e511669a082856a91f958a2fe380bfab3fb22"
+"checksum owning_ref 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37"
+"checksum parking_lot 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "149d8f5b97f3c1133e3cfcd8886449959e856b557ff281e292b733d7c69e005e"
+"checksum parking_lot_core 0.2.10 (registry+https://github.com/rust-lang/crates.io-index)" = "9f35048d735bb93dd115a0030498785971aab3234d311fbe273d020084d26bd8"
+"checksum patricia-trie 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f1e2f638d79aba5c4a71a4f373df6e3cd702250a53b7f0ed4da1e2a7be9737ae"
+"checksum plain_hasher 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "83ae80873992f511142c07d0ec6c44de5636628fdb7e204abd655932ea79d995"
+"checksum proc-macro-hack 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3ba8d4f9257b85eb6cdf13f055cea3190520aab1409ca2ab43493ea4820c25f0"
+"checksum proc-macro-hack-impl 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d5cb6f960ad471404618e9817c0e5d10b1ae74cfdf01fab89ea0641fe7fb2892"
+"checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
+"checksum rand 0.3.22 (registry+https://github.com/rust-lang/crates.io-index)" = "15a732abf9d20f0ad8eeb6f909bf6868722d9a06e1e50802b6a70351f40b4eb1"
+"checksum rand 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "eba5f8cb59cc50ed56be8880a5c7b496bfd9bd26394e176bc67884094145c2c5"
+"checksum rayon 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b614fe08b6665cb9a231d07ac1364b0ef3cb3698f1239ee0c4c3a88a524f54c8"
+"checksum rayon-core 1.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e64b609139d83da75902f88fd6c01820046840a18471e4dfcd5ac7c0f46bea53"
+"checksum redox_syscall 0.1.37 (registry+https://github.com/rust-lang/crates.io-index)" = "0d92eecebad22b767915e4d529f89f28ee96dbbf5a4810d2b844373f136417fd"
+"checksum redox_termios 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7e891cfe48e9100a70a3b6eb652fef28920c117d366339687bd5576160db0f76"
+"checksum regex 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "744554e01ccbd98fff8c457c3b092cd67af62a555a43bfe97ae8a0451f7799fa"
+"checksum regex-syntax 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8e931c58b93d86f080c734bfd2bce7dd0079ae2331235818133c8be7f422e20e"
+"checksum ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)" = "6f7d28b30a72c01b458428e0ae988d4149c20d902346902be881e3edc4bb325c"
+"checksum rlp 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "babe6fce20c0ca9b1582998734c4569082d0ad08e43772a1c6c40aef4f106ef9"
+"checksum rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0ceb8ce7a5e520de349e1fa172baeba4a9e8d5ef06c47471863530bc4972ee1e"
+"checksum rustc-hex 2.0.0 (git+https://github.com/rphmeier/rustc-hex.git)" = "<none>"
+"checksum rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b9743a7670d88d5d52950408ecdb7c71d8986251ab604d4689dd2ca25c9bca69"
+"checksum scopeguard 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "94258f53601af11e6a49f722422f6e3425c52b06245a5cf9bc09908b174f5e27"
+"checksum semver 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7a3186ec9e65071a2095434b1f5bb24838d4e8e130f584c790f6033c79943537"
+"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+"checksum serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)" = "db99f3919e20faa51bb2996057f5031d8685019b5a06139b1ce761da671b8526"
+"checksum serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)" = "f4ba7591cfe93755e89eeecdbcc668885624829b020050e6aec99c2a03bd3fd0"
+"checksum serde_derive_internals 0.19.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6e03f1c9530c3fb0a0a5c9b826bdd9246a5921ae995d75f512ac917fc4dd55b5"
+"checksum smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "44db0ecb22921ef790d17ae13a3f6d15784183ff5f2a01aa32098c7498d2b4b9"
+"checksum stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15132e0e364248108c5e2c02e3ab539be8d6f5d52a01ca9bbf27ed657316f02b"
+"checksum syn 0.11.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d3b891b9015c88c576343b9b3e41c2c11a51c219ef067b264bd9c8aa9b441dad"
+"checksum synom 0.11.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a393066ed9010ebaed60b9eafa373d4b1baac186dd7e008555b0f702b51945b6"
+"checksum termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
+"checksum thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279ef31c19ededf577bfd12dfae728040a21f635b06a24cd670ff510edd38963"
+"checksum time 0.1.39 (registry+https://github.com/rust-lang/crates.io-index)" = "a15375f1df02096fb3317256ce2cee6a1f42fc84ea5ad5fc8c421cfe40c73098"
+"checksum tiny-keccak 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3e9241752647ca572f12c9b520a5d360d9099360c527770647e694001646a1d0"
+"checksum triehash 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9291c7f0fae44858b5e087dd462afb382354120003778f1695b44aab98c7abd7"
+"checksum twox-hash 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "475352206e7a290c5fccc27624a163e8d0d115f7bb60ca18a64fc9ce056d7435"
+"checksum uint 0.1.2 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)" = "<none>"
+"checksum unicode-xid 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "8c1f860d7d29cf02cb2f3f359fd35991af3d30bac52c57d265a3c461074cb4dc"
+"checksum unreachable 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+"checksum untrusted 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "f392d7819dbe58833e26872f5f6f0d68b7bbbe90fc3667e98731c4a15ad9a7ae"
+"checksum utf8-ranges 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "662fab6525a98beff2921d7f61a39e7d59e0b425ebc7d0d9e66d316e55124122"
+"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+"checksum winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "04e3bd221fcbe8a271359c04f21a76db7d0c6028862d1bb5512d85e1e2eb5bb3"
+"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

substrate/demo/runtime/wasm/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "demo-runtime"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+substrate-codec = { path = "../../../substrate/codec", default-features = false }
+substrate-runtime-std = { path = "../../../substrate/runtime-std", default-features = false }
+substrate-runtime-io = { path = "../../../substrate/runtime-io", default-features = false }
+substrate-runtime-support = { path = "../../../substrate/runtime-support", default-features = false }
+substrate-primitives = { path = "../../../substrate/primitives", default-features = false }
+demo-primitives = { path = "../../primitives", default-features = false }
+
+[features]
+default = []
+std = [
+	"substrate-codec/std",
+	"substrate-runtime-io/std",
+	"substrate-runtime-std/std",
+	"substrate-runtime-support/std",
+	"substrate-primitives/std",
+	"demo-primitives/std",
+]
+
+[profile.release]
+panic = "abort"
+
+[workspace]
+members = []

substrate/demo/runtime/wasm/build.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e
+
+cargo +nightly build --target=wasm32-unknown-unknown --release
+for i in demo_runtime
+do
+	wasm-gc target/wasm32-unknown-unknown/release/$i.wasm target/wasm32-unknown-unknown/release/$i.compact.wasm
+done

substrate/demo/runtime/wasm/init.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+
+rustup update nightly
+rustup target add wasm32-unknown-unknown --toolchain nightly
+rustup update stable
+cargo install --git https://github.com/alexcrichton/wasm-gc

substrate/demo/runtime/wasm/src

@@ -0,0 +1 @@
+../src

substrate/demo/runtime/wasm/target/debug/.fingerprint/byteorder-d042eee36ae0c5bf/lib-byteorder-d042eee36ae0c5bf

@@ -0,0 +1 @@
+886af10eac278f98

substrate/demo/runtime/wasm/target/debug/.fingerprint/byteorder-d042eee36ae0c5bf/lib-byteorder-d042eee36ae0c5bf.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":14273275588615045656,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"1.2.1"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-428ca79f7094ae1b/lib-crunchy-428ca79f7094ae1b

@@ -0,0 +1 @@
+7afe5707b6b07892

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-428ca79f7094ae1b/lib-crunchy-428ca79f7094ae1b.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[\"default\", \"limit_128\"]","target":1199109001173133208,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"0.1.6"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-7afe3ee0284c8f65/build-script-build_script_build-7afe3ee0284c8f65

@@ -0,0 +1 @@
+d39dfb72b3b66e9c

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-7afe3ee0284c8f65/build-script-build_script_build-7afe3ee0284c8f65.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[\"default\", \"limit_128\"]","target":17567538301449956701,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"0.1.6"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-aa6f78c4ab60ae0c/build

@@ -0,0 +1 @@
+41e076aa8725cdfd

substrate/demo/runtime/wasm/target/debug/.fingerprint/crunchy-aa6f78c4ab60ae0c/build.json

@@ -0,0 +1 @@
+{"rustc":0,"features":"","target":0,"profile":0,"deps":[],"local":[{"Precalculated":"0.1.6"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/fixed-hash-1efcfb7c375dbdea/lib-fixed_hash-1efcfb7c375dbdea

@@ -0,0 +1 @@
+d79a3e2b5eee98da

substrate/demo/runtime/wasm/target/debug/.fingerprint/fixed-hash-1efcfb7c375dbdea/lib-fixed_hash-1efcfb7c375dbdea.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":5013696897081889700,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"8dc457899afdaf968ff7f16140b03d1e37b01d71"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/hex-literal-e445a623434092c6/lib-hex_literal-e445a623434092c6

@@ -0,0 +1 @@
+59fa4faf04e0dda9

substrate/demo/runtime/wasm/target/debug/.fingerprint/hex-literal-e445a623434092c6/lib-hex_literal-e445a623434092c6.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":12509387672031407172,"profile":731176819336294830,"deps":[["hex-literal-impl v0.1.0",2529969908488632522],["proc-macro-hack v0.4.0",4641094510796254347]],"local":[{"Precalculated":"0.1.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/hex-literal-impl-262ff3d0633a3545/lib-hex_literal_impl-262ff3d0633a3545

@@ -0,0 +1 @@
+ca78e4373a421c23

substrate/demo/runtime/wasm/target/debug/.fingerprint/hex-literal-impl-262ff3d0633a3545/lib-hex_literal_impl-262ff3d0633a3545.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":11241083843197735319,"profile":731176819336294830,"deps":[["proc-macro-hack v0.4.0",4641094510796254347]],"local":[{"Precalculated":"0.1.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/proc-macro-hack-a09c0fefc7feaa65/lib-proc_macro_hack-a09c0fefc7feaa65

@@ -0,0 +1 @@
+8bac0635de7a6840

substrate/demo/runtime/wasm/target/debug/.fingerprint/proc-macro-hack-a09c0fefc7feaa65/lib-proc_macro_hack-a09c0fefc7feaa65.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":9698523924128815470,"profile":731176819336294830,"deps":[["proc-macro-hack-impl v0.4.0",13894909820210766557]],"local":[{"Precalculated":"0.4.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/proc-macro-hack-impl-5f7a0d56379ec695/lib-proc_macro_hack_impl-5f7a0d56379ec695

@@ -0,0 +1 @@
+dde2bff3dca2d4c0

substrate/demo/runtime/wasm/target/debug/.fingerprint/proc-macro-hack-impl-5f7a0d56379ec695/lib-proc_macro_hack_impl-5f7a0d56379ec695.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":5402284247355296551,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"0.4.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-0a1fe761df3cd1a4/lib-pwasm_alloc-0a1fe761df3cd1a4

@@ -0,0 +1 @@
+62c2b5394c446752

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-0a1fe761df3cd1a4/lib-pwasm_alloc-0a1fe761df3cd1a4.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":12003829590854714571,"profile":731176819336294830,"deps":[["pwasm-libc v0.1.0 (file:///Users/gav/Core/polkadot/substrate/pwasm-libc)",7485877435958704242]],"local":[{"MtimeBased":[[1518113559,620179670],"/Users/gav/Core/polkadot/polkadot/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-0a1fe761df3cd1a4/dep-lib-pwasm_alloc-0a1fe761df3cd1a4"]}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-3fac0f3c387c9ca9/build

@@ -0,0 +1 @@
+f912c314c0953983

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-3fac0f3c387c9ca9/build.json

@@ -0,0 +1 @@
+{"rustc":0,"features":"","target":0,"profile":0,"deps":[],"local":[{"Precalculated":"1518109789.829363592s (/Users/gav/Core/polkadot/substrate/pwasm-alloc/src/lib.rs)"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-d447833ce9aea37c/build-script-build_script_build-d447833ce9aea37c

@@ -0,0 +1 @@
+a2ee1a33b63084e2

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-d447833ce9aea37c/build-script-build_script_build-d447833ce9aea37c.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":14921784624115234902,"profile":731176819336294830,"deps":[["rustc_version v0.2.1",8668969671064323358]],"local":[{"MtimeBased":[[1518113558,818612709],"/Users/gav/Core/polkadot/polkadot/runtime/wasm/target/debug/.fingerprint/pwasm-alloc-d447833ce9aea37c/dep-build-script-build_script_build-d447833ce9aea37c"]}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-libc-3c1fc4945ffb588c/lib-pwasm_libc-3c1fc4945ffb588c

@@ -0,0 +1 @@
+72386ebadd2de367

substrate/demo/runtime/wasm/target/debug/.fingerprint/pwasm-libc-3c1fc4945ffb588c/lib-pwasm_libc-3c1fc4945ffb588c.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":6884360048357664070,"profile":731176819336294830,"deps":[],"local":[{"MtimeBased":[[1518113555,449989277],"/Users/gav/Core/polkadot/polkadot/runtime/wasm/target/debug/.fingerprint/pwasm-libc-3c1fc4945ffb588c/dep-lib-pwasm_libc-3c1fc4945ffb588c"]}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/rustc-hex-36874c31cb1e074b/lib-rustc_hex-36874c31cb1e074b

@@ -0,0 +1 @@
+a9bba54c23cf64a7

substrate/demo/runtime/wasm/target/debug/.fingerprint/rustc-hex-36874c31cb1e074b/lib-rustc_hex-36874c31cb1e074b.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":16670102957649486419,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"ee2ec40b9062ac7769ccb9dc891d6dc2cc9009d7"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/rustc_version-5b6a601163a6fa82/lib-rustc_version-5b6a601163a6fa82

@@ -0,0 +1 @@
+1e856c54fc5d4e78

substrate/demo/runtime/wasm/target/debug/.fingerprint/rustc_version-5b6a601163a6fa82/lib-rustc_version-5b6a601163a6fa82.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":1494946782096695454,"profile":731176819336294830,"deps":[["semver v0.6.0",9778926162762572505]],"local":[{"Precalculated":"0.2.1"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/semver-c1ec2df066d48dfc/lib-semver-c1ec2df066d48dfc

@@ -0,0 +1 @@
+d9a23cb888b9b587

substrate/demo/runtime/wasm/target/debug/.fingerprint/semver-c1ec2df066d48dfc/lib-semver-c1ec2df066d48dfc.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[\"default\"]","target":356893538095437893,"profile":731176819336294830,"deps":[["semver-parser v0.7.0",6177733820198020260]],"local":[{"Precalculated":"0.6.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/semver-parser-76e51e73206527e9/lib-semver_parser-76e51e73206527e9

@@ -0,0 +1 @@
+a4e4d1ad2db8bb55

substrate/demo/runtime/wasm/target/debug/.fingerprint/semver-parser-76e51e73206527e9/lib-semver_parser-76e51e73206527e9.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":11743311642726602848,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"0.7.0"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/serde-133bbc10deb4b2bf/lib-serde-133bbc10deb4b2bf

@@ -0,0 +1 @@
+1497f6e800bfad1b

substrate/demo/runtime/wasm/target/debug/.fingerprint/serde-133bbc10deb4b2bf/lib-serde-133bbc10deb4b2bf.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":13503936060867580529,"profile":731176819336294830,"deps":[],"local":[{"Precalculated":"1.0.27"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a91148a2d5741e6f/build

@@ -0,0 +1 @@
+6c0d5ba5963cee2f

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a91148a2d5741e6f/build.json

@@ -0,0 +1 @@
+{"rustc":0,"features":"","target":0,"profile":0,"deps":[],"local":[{"Precalculated":"1518109789.837756099s (/Users/gav/Core/polkadot/substrate/runtime-io/without_std.rs)"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a9866f32f3b51382/build-script-build_script_build-a9866f32f3b51382

@@ -0,0 +1 @@
+99c56cc5fc011d23

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a9866f32f3b51382/build-script-build_script_build-a9866f32f3b51382.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":12308848387402016909,"profile":731176819336294830,"deps":[["rustc_version v0.2.1",8668969671064323358]],"local":[{"MtimeBased":[[1518113558,689570399],"/Users/gav/Core/polkadot/polkadot/runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a9866f32f3b51382/dep-build-script-build_script_build-a9866f32f3b51382"]}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-6fe626a9de5bf134/build-script-build_script_build-6fe626a9de5bf134

@@ -0,0 +1 @@
+0d3fbc3a97398222

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-6fe626a9de5bf134/build-script-build_script_build-6fe626a9de5bf134.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":15217767247624158212,"profile":731176819336294830,"deps":[["rustc_version v0.2.1",8668969671064323358]],"local":[{"MtimeBased":[[1518113559,163214299],"/Users/gav/Core/polkadot/polkadot/runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-6fe626a9de5bf134/dep-build-script-build_script_build-6fe626a9de5bf134"]}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-9dd6df43308d313a/build

@@ -0,0 +1 @@
+7923bcba1225a62d

substrate/demo/runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-9dd6df43308d313a/build.json

@@ -0,0 +1 @@
+{"rustc":0,"features":"","target":0,"profile":0,"deps":[],"local":[{"Precalculated":"1518109789.840012697s (/Users/gav/Core/polkadot/substrate/runtime-std/without_std.rs)"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/uint-00ce69ad7e7eb4d6/lib-uint-00ce69ad7e7eb4d6

@@ -0,0 +1 @@
+dca36084f0f5085a

substrate/demo/runtime/wasm/target/debug/.fingerprint/uint-00ce69ad7e7eb4d6/lib-uint-00ce69ad7e7eb4d6.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":16759311700645620298,"profile":731176819336294830,"deps":[["byteorder v1.2.1",10993048835373230728]],"local":[{"Precalculated":"8dc457899afdaf968ff7f16140b03d1e37b01d71"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/uint-07239eb1916014b7/build-script-build_script_build-07239eb1916014b7

@@ -0,0 +1 @@
+6756bb8857284f95

substrate/demo/runtime/wasm/target/debug/.fingerprint/uint-07239eb1916014b7/build-script-build_script_build-07239eb1916014b7.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":6771221677873906921,"profile":731176819336294830,"deps":[["rustc_version v0.2.1",8668969671064323358]],"local":[{"Precalculated":"8dc457899afdaf968ff7f16140b03d1e37b01d71"}],"rustflags":[]}

substrate/demo/runtime/wasm/target/debug/.fingerprint/uint-d3e5c9930d5fba2d/build

@@ -0,0 +1 @@
+4c01460e12fb5129