Introduce substrate-demo

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

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

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

substrate/demo/runtime/wasm/target/debug/build/crunchy-7afe3ee0284c8f65/build_script_build-7afe3ee0284c8f65.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.build_script_build-7afe3ee0284c8f65</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

substrate/demo/runtime/wasm/target/debug/build/crunchy-aa6f78c4ab60ae0c/out/lib.rs

@@ -0,0 +1,815 @@
+
+/// Unroll the given for loop
+///
+/// Example:
+///
+/// ```ignore
+/// unroll! {
+///   for i in 0..5 {
+///     println!("Iteration {}", i);
+///   }
+/// }
+/// ```
+///
+/// will expand into:
+///
+/// ```ignore
+/// { println!("Iteration {}", 0); }
+/// { println!("Iteration {}", 1); }
+/// { println!("Iteration {}", 2); }
+/// { println!("Iteration {}", 3); }
+/// { println!("Iteration {}", 4); }
+/// ```
+#[macro_export]
+macro_rules! unroll {
+    (for $v:ident in 0..0 $c:block) => {};
+
+    (for $v:ident in 0..$b:tt {$($c:tt)*}) => {
+        #[allow(non_upper_case_globals)]
+        { unroll!(@$v, 0, $b, {$($c)*}); }
+    };
+
+    (@$v:ident, $a:expr, 0, $c:block) => {
+        { const $v: usize = $a; $c }
+    };
+
+    (@$v:ident, $a:expr, 1, $c:block) => {
+        { const $v: usize = $a; $c }
+    };
+
+    (@$v:ident, $a:expr, 2, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+    };
+
+    (@$v:ident, $a:expr, 3, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+    };
+
+    (@$v:ident, $a:expr, 4, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+    };
+
+    (@$v:ident, $a:expr, 5, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+    };
+
+    (@$v:ident, $a:expr, 6, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+    };
+
+    (@$v:ident, $a:expr, 7, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+    };
+
+    (@$v:ident, $a:expr, 8, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+    };
+
+    (@$v:ident, $a:expr, 9, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+    };
+
+    (@$v:ident, $a:expr, 10, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+    };
+
+    (@$v:ident, $a:expr, 11, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+    };
+
+    (@$v:ident, $a:expr, 12, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+        { const $v: usize = $a + 11; $c }
+    };
+
+    (@$v:ident, $a:expr, 13, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+        { const $v: usize = $a + 11; $c }
+        { const $v: usize = $a + 12; $c }
+    };
+
+    (@$v:ident, $a:expr, 14, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+        { const $v: usize = $a + 11; $c }
+        { const $v: usize = $a + 12; $c }
+        { const $v: usize = $a + 13; $c }
+    };
+
+    (@$v:ident, $a:expr, 15, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+        { const $v: usize = $a + 11; $c }
+        { const $v: usize = $a + 12; $c }
+        { const $v: usize = $a + 13; $c }
+        { const $v: usize = $a + 14; $c }
+    };
+
+    (@$v:ident, $a:expr, 16, $c:block) => {
+        { const $v: usize = $a; $c }
+        { const $v: usize = $a + 1; $c }
+        { const $v: usize = $a + 2; $c }
+        { const $v: usize = $a + 3; $c }
+        { const $v: usize = $a + 4; $c }
+        { const $v: usize = $a + 5; $c }
+        { const $v: usize = $a + 6; $c }
+        { const $v: usize = $a + 7; $c }
+        { const $v: usize = $a + 8; $c }
+        { const $v: usize = $a + 9; $c }
+        { const $v: usize = $a + 10; $c }
+        { const $v: usize = $a + 11; $c }
+        { const $v: usize = $a + 12; $c }
+        { const $v: usize = $a + 13; $c }
+        { const $v: usize = $a + 14; $c }
+        { const $v: usize = $a + 15; $c }
+    };
+
+    (@$v:ident, $a:expr, 17, $c:block) => {
+        unroll!(@$v, $a, 16, $c);
+        { const $v: usize = $a + 16; $c }
+    };
+
+    (@$v:ident, $a:expr, 18, $c:block) => {
+        unroll!(@$v, $a, 9, $c);
+        unroll!(@$v, $a + 9, 9, $c);
+    };
+
+    (@$v:ident, $a:expr, 19, $c:block) => {
+        unroll!(@$v, $a, 18, $c);
+        { const $v: usize = $a + 18; $c }
+    };
+
+    (@$v:ident, $a:expr, 20, $c:block) => {
+        unroll!(@$v, $a, 10, $c);
+        unroll!(@$v, $a + 10, 10, $c);
+    };
+
+    (@$v:ident, $a:expr, 21, $c:block) => {
+        unroll!(@$v, $a, 20, $c);
+        { const $v: usize = $a + 20; $c }
+    };
+
+    (@$v:ident, $a:expr, 22, $c:block) => {
+        unroll!(@$v, $a, 11, $c);
+        unroll!(@$v, $a + 11, 11, $c);
+    };
+
+    (@$v:ident, $a:expr, 23, $c:block) => {
+        unroll!(@$v, $a, 22, $c);
+        { const $v: usize = $a + 22; $c }
+    };
+
+    (@$v:ident, $a:expr, 24, $c:block) => {
+        unroll!(@$v, $a, 12, $c);
+        unroll!(@$v, $a + 12, 12, $c);
+    };
+
+    (@$v:ident, $a:expr, 25, $c:block) => {
+        unroll!(@$v, $a, 24, $c);
+        { const $v: usize = $a + 24; $c }
+    };
+
+    (@$v:ident, $a:expr, 26, $c:block) => {
+        unroll!(@$v, $a, 13, $c);
+        unroll!(@$v, $a + 13, 13, $c);
+    };
+
+    (@$v:ident, $a:expr, 27, $c:block) => {
+        unroll!(@$v, $a, 26, $c);
+        { const $v: usize = $a + 26; $c }
+    };
+
+    (@$v:ident, $a:expr, 28, $c:block) => {
+        unroll!(@$v, $a, 14, $c);
+        unroll!(@$v, $a + 14, 14, $c);
+    };
+
+    (@$v:ident, $a:expr, 29, $c:block) => {
+        unroll!(@$v, $a, 28, $c);
+        { const $v: usize = $a + 28; $c }
+    };
+
+    (@$v:ident, $a:expr, 30, $c:block) => {
+        unroll!(@$v, $a, 15, $c);
+        unroll!(@$v, $a + 15, 15, $c);
+    };
+
+    (@$v:ident, $a:expr, 31, $c:block) => {
+        unroll!(@$v, $a, 30, $c);
+        { const $v: usize = $a + 30; $c }
+    };
+
+    (@$v:ident, $a:expr, 32, $c:block) => {
+        unroll!(@$v, $a, 16, $c);
+        unroll!(@$v, $a + 16, 16, $c);
+    };
+
+    (@$v:ident, $a:expr, 33, $c:block) => {
+        unroll!(@$v, $a, 32, $c);
+        { const $v: usize = $a + 32; $c }
+    };
+
+    (@$v:ident, $a:expr, 34, $c:block) => {
+        unroll!(@$v, $a, 17, $c);
+        unroll!(@$v, $a + 17, 17, $c);
+    };
+
+    (@$v:ident, $a:expr, 35, $c:block) => {
+        unroll!(@$v, $a, 34, $c);
+        { const $v: usize = $a + 34; $c }
+    };
+
+    (@$v:ident, $a:expr, 36, $c:block) => {
+        unroll!(@$v, $a, 18, $c);
+        unroll!(@$v, $a + 18, 18, $c);
+    };
+
+    (@$v:ident, $a:expr, 37, $c:block) => {
+        unroll!(@$v, $a, 36, $c);
+        { const $v: usize = $a + 36; $c }
+    };
+
+    (@$v:ident, $a:expr, 38, $c:block) => {
+        unroll!(@$v, $a, 19, $c);
+        unroll!(@$v, $a + 19, 19, $c);
+    };
+
+    (@$v:ident, $a:expr, 39, $c:block) => {
+        unroll!(@$v, $a, 38, $c);
+        { const $v: usize = $a + 38; $c }
+    };
+
+    (@$v:ident, $a:expr, 40, $c:block) => {
+        unroll!(@$v, $a, 20, $c);
+        unroll!(@$v, $a + 20, 20, $c);
+    };
+
+    (@$v:ident, $a:expr, 41, $c:block) => {
+        unroll!(@$v, $a, 40, $c);
+        { const $v: usize = $a + 40; $c }
+    };
+
+    (@$v:ident, $a:expr, 42, $c:block) => {
+        unroll!(@$v, $a, 21, $c);
+        unroll!(@$v, $a + 21, 21, $c);
+    };
+
+    (@$v:ident, $a:expr, 43, $c:block) => {
+        unroll!(@$v, $a, 42, $c);
+        { const $v: usize = $a + 42; $c }
+    };
+
+    (@$v:ident, $a:expr, 44, $c:block) => {
+        unroll!(@$v, $a, 22, $c);
+        unroll!(@$v, $a + 22, 22, $c);
+    };
+
+    (@$v:ident, $a:expr, 45, $c:block) => {
+        unroll!(@$v, $a, 44, $c);
+        { const $v: usize = $a + 44; $c }
+    };
+
+    (@$v:ident, $a:expr, 46, $c:block) => {
+        unroll!(@$v, $a, 23, $c);
+        unroll!(@$v, $a + 23, 23, $c);
+    };
+
+    (@$v:ident, $a:expr, 47, $c:block) => {
+        unroll!(@$v, $a, 46, $c);
+        { const $v: usize = $a + 46; $c }
+    };
+
+    (@$v:ident, $a:expr, 48, $c:block) => {
+        unroll!(@$v, $a, 24, $c);
+        unroll!(@$v, $a + 24, 24, $c);
+    };
+
+    (@$v:ident, $a:expr, 49, $c:block) => {
+        unroll!(@$v, $a, 48, $c);
+        { const $v: usize = $a + 48; $c }
+    };
+
+    (@$v:ident, $a:expr, 50, $c:block) => {
+        unroll!(@$v, $a, 25, $c);
+        unroll!(@$v, $a + 25, 25, $c);
+    };
+
+    (@$v:ident, $a:expr, 51, $c:block) => {
+        unroll!(@$v, $a, 50, $c);
+        { const $v: usize = $a + 50; $c }
+    };
+
+    (@$v:ident, $a:expr, 52, $c:block) => {
+        unroll!(@$v, $a, 26, $c);
+        unroll!(@$v, $a + 26, 26, $c);
+    };
+
+    (@$v:ident, $a:expr, 53, $c:block) => {
+        unroll!(@$v, $a, 52, $c);
+        { const $v: usize = $a + 52; $c }
+    };
+
+    (@$v:ident, $a:expr, 54, $c:block) => {
+        unroll!(@$v, $a, 27, $c);
+        unroll!(@$v, $a + 27, 27, $c);
+    };
+
+    (@$v:ident, $a:expr, 55, $c:block) => {
+        unroll!(@$v, $a, 54, $c);
+        { const $v: usize = $a + 54; $c }
+    };
+
+    (@$v:ident, $a:expr, 56, $c:block) => {
+        unroll!(@$v, $a, 28, $c);
+        unroll!(@$v, $a + 28, 28, $c);
+    };
+
+    (@$v:ident, $a:expr, 57, $c:block) => {
+        unroll!(@$v, $a, 56, $c);
+        { const $v: usize = $a + 56; $c }
+    };
+
+    (@$v:ident, $a:expr, 58, $c:block) => {
+        unroll!(@$v, $a, 29, $c);
+        unroll!(@$v, $a + 29, 29, $c);
+    };
+
+    (@$v:ident, $a:expr, 59, $c:block) => {
+        unroll!(@$v, $a, 58, $c);
+        { const $v: usize = $a + 58; $c }
+    };
+
+    (@$v:ident, $a:expr, 60, $c:block) => {
+        unroll!(@$v, $a, 30, $c);
+        unroll!(@$v, $a + 30, 30, $c);
+    };
+
+    (@$v:ident, $a:expr, 61, $c:block) => {
+        unroll!(@$v, $a, 60, $c);
+        { const $v: usize = $a + 60; $c }
+    };
+
+    (@$v:ident, $a:expr, 62, $c:block) => {
+        unroll!(@$v, $a, 31, $c);
+        unroll!(@$v, $a + 31, 31, $c);
+    };
+
+    (@$v:ident, $a:expr, 63, $c:block) => {
+        unroll!(@$v, $a, 62, $c);
+        { const $v: usize = $a + 62; $c }
+    };
+
+    (@$v:ident, $a:expr, 64, $c:block) => {
+        unroll!(@$v, $a, 32, $c);
+        unroll!(@$v, $a + 32, 32, $c);
+    };
+
+    (@$v:ident, $a:expr, 65, $c:block) => {
+        unroll!(@$v, $a, 64, $c);
+        { const $v: usize = $a + 64; $c }
+    };
+
+    (@$v:ident, $a:expr, 66, $c:block) => {
+        unroll!(@$v, $a, 33, $c);
+        unroll!(@$v, $a + 33, 33, $c);
+    };
+
+    (@$v:ident, $a:expr, 67, $c:block) => {
+        unroll!(@$v, $a, 66, $c);
+        { const $v: usize = $a + 66; $c }
+    };
+
+    (@$v:ident, $a:expr, 68, $c:block) => {
+        unroll!(@$v, $a, 34, $c);
+        unroll!(@$v, $a + 34, 34, $c);
+    };
+
+    (@$v:ident, $a:expr, 69, $c:block) => {
+        unroll!(@$v, $a, 68, $c);
+        { const $v: usize = $a + 68; $c }
+    };
+
+    (@$v:ident, $a:expr, 70, $c:block) => {
+        unroll!(@$v, $a, 35, $c);
+        unroll!(@$v, $a + 35, 35, $c);
+    };
+
+    (@$v:ident, $a:expr, 71, $c:block) => {
+        unroll!(@$v, $a, 70, $c);
+        { const $v: usize = $a + 70; $c }
+    };
+
+    (@$v:ident, $a:expr, 72, $c:block) => {
+        unroll!(@$v, $a, 36, $c);
+        unroll!(@$v, $a + 36, 36, $c);
+    };
+
+    (@$v:ident, $a:expr, 73, $c:block) => {
+        unroll!(@$v, $a, 72, $c);
+        { const $v: usize = $a + 72; $c }
+    };
+
+    (@$v:ident, $a:expr, 74, $c:block) => {
+        unroll!(@$v, $a, 37, $c);
+        unroll!(@$v, $a + 37, 37, $c);
+    };
+
+    (@$v:ident, $a:expr, 75, $c:block) => {
+        unroll!(@$v, $a, 74, $c);
+        { const $v: usize = $a + 74; $c }
+    };
+
+    (@$v:ident, $a:expr, 76, $c:block) => {
+        unroll!(@$v, $a, 38, $c);
+        unroll!(@$v, $a + 38, 38, $c);
+    };
+
+    (@$v:ident, $a:expr, 77, $c:block) => {
+        unroll!(@$v, $a, 76, $c);
+        { const $v: usize = $a + 76; $c }
+    };
+
+    (@$v:ident, $a:expr, 78, $c:block) => {
+        unroll!(@$v, $a, 39, $c);
+        unroll!(@$v, $a + 39, 39, $c);
+    };
+
+    (@$v:ident, $a:expr, 79, $c:block) => {
+        unroll!(@$v, $a, 78, $c);
+        { const $v: usize = $a + 78; $c }
+    };
+
+    (@$v:ident, $a:expr, 80, $c:block) => {
+        unroll!(@$v, $a, 40, $c);
+        unroll!(@$v, $a + 40, 40, $c);
+    };
+
+    (@$v:ident, $a:expr, 81, $c:block) => {
+        unroll!(@$v, $a, 80, $c);
+        { const $v: usize = $a + 80; $c }
+    };
+
+    (@$v:ident, $a:expr, 82, $c:block) => {
+        unroll!(@$v, $a, 41, $c);
+        unroll!(@$v, $a + 41, 41, $c);
+    };
+
+    (@$v:ident, $a:expr, 83, $c:block) => {
+        unroll!(@$v, $a, 82, $c);
+        { const $v: usize = $a + 82; $c }
+    };
+
+    (@$v:ident, $a:expr, 84, $c:block) => {
+        unroll!(@$v, $a, 42, $c);
+        unroll!(@$v, $a + 42, 42, $c);
+    };
+
+    (@$v:ident, $a:expr, 85, $c:block) => {
+        unroll!(@$v, $a, 84, $c);
+        { const $v: usize = $a + 84; $c }
+    };
+
+    (@$v:ident, $a:expr, 86, $c:block) => {
+        unroll!(@$v, $a, 43, $c);
+        unroll!(@$v, $a + 43, 43, $c);
+    };
+
+    (@$v:ident, $a:expr, 87, $c:block) => {
+        unroll!(@$v, $a, 86, $c);
+        { const $v: usize = $a + 86; $c }
+    };
+
+    (@$v:ident, $a:expr, 88, $c:block) => {
+        unroll!(@$v, $a, 44, $c);
+        unroll!(@$v, $a + 44, 44, $c);
+    };
+
+    (@$v:ident, $a:expr, 89, $c:block) => {
+        unroll!(@$v, $a, 88, $c);
+        { const $v: usize = $a + 88; $c }
+    };
+
+    (@$v:ident, $a:expr, 90, $c:block) => {
+        unroll!(@$v, $a, 45, $c);
+        unroll!(@$v, $a + 45, 45, $c);
+    };
+
+    (@$v:ident, $a:expr, 91, $c:block) => {
+        unroll!(@$v, $a, 90, $c);
+        { const $v: usize = $a + 90; $c }
+    };
+
+    (@$v:ident, $a:expr, 92, $c:block) => {
+        unroll!(@$v, $a, 46, $c);
+        unroll!(@$v, $a + 46, 46, $c);
+    };
+
+    (@$v:ident, $a:expr, 93, $c:block) => {
+        unroll!(@$v, $a, 92, $c);
+        { const $v: usize = $a + 92; $c }
+    };
+
+    (@$v:ident, $a:expr, 94, $c:block) => {
+        unroll!(@$v, $a, 47, $c);
+        unroll!(@$v, $a + 47, 47, $c);
+    };
+
+    (@$v:ident, $a:expr, 95, $c:block) => {
+        unroll!(@$v, $a, 94, $c);
+        { const $v: usize = $a + 94; $c }
+    };
+
+    (@$v:ident, $a:expr, 96, $c:block) => {
+        unroll!(@$v, $a, 48, $c);
+        unroll!(@$v, $a + 48, 48, $c);
+    };
+
+    (@$v:ident, $a:expr, 97, $c:block) => {
+        unroll!(@$v, $a, 96, $c);
+        { const $v: usize = $a + 96; $c }
+    };
+
+    (@$v:ident, $a:expr, 98, $c:block) => {
+        unroll!(@$v, $a, 49, $c);
+        unroll!(@$v, $a + 49, 49, $c);
+    };
+
+    (@$v:ident, $a:expr, 99, $c:block) => {
+        unroll!(@$v, $a, 98, $c);
+        { const $v: usize = $a + 98; $c }
+    };
+
+    (@$v:ident, $a:expr, 100, $c:block) => {
+        unroll!(@$v, $a, 50, $c);
+        unroll!(@$v, $a + 50, 50, $c);
+    };
+
+    (@$v:ident, $a:expr, 101, $c:block) => {
+        unroll!(@$v, $a, 100, $c);
+        { const $v: usize = $a + 100; $c }
+    };
+
+    (@$v:ident, $a:expr, 102, $c:block) => {
+        unroll!(@$v, $a, 51, $c);
+        unroll!(@$v, $a + 51, 51, $c);
+    };
+
+    (@$v:ident, $a:expr, 103, $c:block) => {
+        unroll!(@$v, $a, 102, $c);
+        { const $v: usize = $a + 102; $c }
+    };
+
+    (@$v:ident, $a:expr, 104, $c:block) => {
+        unroll!(@$v, $a, 52, $c);
+        unroll!(@$v, $a + 52, 52, $c);
+    };
+
+    (@$v:ident, $a:expr, 105, $c:block) => {
+        unroll!(@$v, $a, 104, $c);
+        { const $v: usize = $a + 104; $c }
+    };
+
+    (@$v:ident, $a:expr, 106, $c:block) => {
+        unroll!(@$v, $a, 53, $c);
+        unroll!(@$v, $a + 53, 53, $c);
+    };
+
+    (@$v:ident, $a:expr, 107, $c:block) => {
+        unroll!(@$v, $a, 106, $c);
+        { const $v: usize = $a + 106; $c }
+    };
+
+    (@$v:ident, $a:expr, 108, $c:block) => {
+        unroll!(@$v, $a, 54, $c);
+        unroll!(@$v, $a + 54, 54, $c);
+    };
+
+    (@$v:ident, $a:expr, 109, $c:block) => {
+        unroll!(@$v, $a, 108, $c);
+        { const $v: usize = $a + 108; $c }
+    };
+
+    (@$v:ident, $a:expr, 110, $c:block) => {
+        unroll!(@$v, $a, 55, $c);
+        unroll!(@$v, $a + 55, 55, $c);
+    };
+
+    (@$v:ident, $a:expr, 111, $c:block) => {
+        unroll!(@$v, $a, 110, $c);
+        { const $v: usize = $a + 110; $c }
+    };
+
+    (@$v:ident, $a:expr, 112, $c:block) => {
+        unroll!(@$v, $a, 56, $c);
+        unroll!(@$v, $a + 56, 56, $c);
+    };
+
+    (@$v:ident, $a:expr, 113, $c:block) => {
+        unroll!(@$v, $a, 112, $c);
+        { const $v: usize = $a + 112; $c }
+    };
+
+    (@$v:ident, $a:expr, 114, $c:block) => {
+        unroll!(@$v, $a, 57, $c);
+        unroll!(@$v, $a + 57, 57, $c);
+    };
+
+    (@$v:ident, $a:expr, 115, $c:block) => {
+        unroll!(@$v, $a, 114, $c);
+        { const $v: usize = $a + 114; $c }
+    };
+
+    (@$v:ident, $a:expr, 116, $c:block) => {
+        unroll!(@$v, $a, 58, $c);
+        unroll!(@$v, $a + 58, 58, $c);
+    };
+
+    (@$v:ident, $a:expr, 117, $c:block) => {
+        unroll!(@$v, $a, 116, $c);
+        { const $v: usize = $a + 116; $c }
+    };
+
+    (@$v:ident, $a:expr, 118, $c:block) => {
+        unroll!(@$v, $a, 59, $c);
+        unroll!(@$v, $a + 59, 59, $c);
+    };
+
+    (@$v:ident, $a:expr, 119, $c:block) => {
+        unroll!(@$v, $a, 118, $c);
+        { const $v: usize = $a + 118; $c }
+    };
+
+    (@$v:ident, $a:expr, 120, $c:block) => {
+        unroll!(@$v, $a, 60, $c);
+        unroll!(@$v, $a + 60, 60, $c);
+    };
+
+    (@$v:ident, $a:expr, 121, $c:block) => {
+        unroll!(@$v, $a, 120, $c);
+        { const $v: usize = $a + 120; $c }
+    };
+
+    (@$v:ident, $a:expr, 122, $c:block) => {
+        unroll!(@$v, $a, 61, $c);
+        unroll!(@$v, $a + 61, 61, $c);
+    };
+
+    (@$v:ident, $a:expr, 123, $c:block) => {
+        unroll!(@$v, $a, 122, $c);
+        { const $v: usize = $a + 122; $c }
+    };
+
+    (@$v:ident, $a:expr, 124, $c:block) => {
+        unroll!(@$v, $a, 62, $c);
+        unroll!(@$v, $a + 62, 62, $c);
+    };
+
+    (@$v:ident, $a:expr, 125, $c:block) => {
+        unroll!(@$v, $a, 124, $c);
+        { const $v: usize = $a + 124; $c }
+    };
+
+    (@$v:ident, $a:expr, 126, $c:block) => {
+        unroll!(@$v, $a, 63, $c);
+        unroll!(@$v, $a + 63, 63, $c);
+    };
+
+    (@$v:ident, $a:expr, 127, $c:block) => {
+        unroll!(@$v, $a, 126, $c);
+        { const $v: usize = $a + 126; $c }
+    };
+
+    (@$v:ident, $a:expr, 128, $c:block) => {
+        unroll!(@$v, $a, 64, $c);
+        unroll!(@$v, $a + 64, 64, $c);
+    };
+
+}
+
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_all() {
+        {
+            let a: Vec<usize> = vec![];
+            unroll! {
+                for i in 0..0 {
+                    a.push(i);
+                }
+            }
+            assert_eq!(a, (0..0).collect::<Vec<usize>>());
+        }
+        {
+            let mut a: Vec<usize> = vec![];
+            unroll! {
+                for i in 0..1 {
+                    a.push(i);
+                }
+            }
+            assert_eq!(a, (0..1).collect::<Vec<usize>>());
+        }
+        {
+            let mut a: Vec<usize> = vec![];
+            unroll! {
+                for i in 0..128 {
+                    a.push(i);
+                }
+            }
+            assert_eq!(a, (0..128).collect::<Vec<usize>>());
+        }
+    }
+}