Many renames.

- Everything polkadot becomes polkadot-.
- Wasm (substrate) executor tests split from Wasm (Polkadot) runtime and
built independently.

substrate/polkadot-runtime/Cargo.toml

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

substrate/polkadot-runtime/src/genesismap.rs

@@ -0,0 +1,91 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Tool for creating the genesis block.
+
+use std::collections::HashMap;
+use runtime_io::twox_128;
+use codec::{KeyedVec, Joiner};
+use support::Hashable;
+use polkadot_primitives::{BlockNumber, Block, AccountId};
+use runtime::staking::Balance;
+
+/// Configuration of a general Polkadot 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/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm").to_vec();
+		vec![
+			(&b"gov:apr"[..], vec![].join(&self.approval_ratio)),
+			(&b"ses:len"[..], vec![].join(&self.session_length)),
+			(&b"ses:val:len"[..], vec![].join(&(self.validators.len() as u32))),
+			(&b"sta:wil:len"[..], vec![].join(&0u32)),
+			(&b"sta:spe"[..], vec![].join(&self.sessions_per_era)),
+			(&b"sta:vac"[..], vec![].join(&(self.validators.len() as u32))),
+			(&b"sta:era"[..], vec![].join(&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![].join(account)))
+			).chain(self.authorities.iter()
+				.enumerate()
+				.map(|(i, account)| ((i as u32).to_keyed_vec(b":auth:"), vec![].join(account)))
+			).chain(self.balances.iter()
+				.map(|&(account, balance)| (account.to_keyed_vec(b"sta:bal:"), vec![].join(&balance)))
+			)
+			.map(|(k, v)| (twox_128(&k[..])[..].to_vec(), v.to_vec()))
+			.chain(vec![
+				(b":code"[..].into(), wasm_runtime),
+				(b":auth:len"[..].into(), vec![].join(&(self.authorities.len() as u32))),
+			].into_iter())
+			.chain(self.authorities.iter()
+				.enumerate()
+				.map(|(i, account)| ((i as u32).to_keyed_vec(b":auth:"), vec![].join(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().to_vec()
+	]
+}

substrate/polkadot-runtime/src/lib.rs

@@ -0,0 +1,121 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! The Polkadot 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;
+
+#[cfg(feature = "std")]
+extern crate rustc_hex;
+
+extern crate substrate_codec as codec;
+extern crate substrate_primitives;
+extern crate polkadot_primitives;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
+
+#[macro_use]
+pub mod support;
+pub mod runtime;
+
+#[cfg(feature = "std")]
+pub mod genesismap;
+
+use rstd::prelude::*;
+use codec::Slicable;
+use polkadot_primitives::{Header, Block, UncheckedTransaction};
+
+/// Type definitions and helpers for transactions.
+pub mod transaction {
+	use rstd::ops;
+	use polkadot_primitives::Signature;
+	pub use polkadot_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::to_vec(&tx.transaction);
+		if ::runtime_io::ed25519_verify(&tx.signature.0, &msg, &tx.transaction.signed) {
+			Ok(CheckedTransaction(tx))
+		} else {
+			Err(tx)
+		}
+	}
+}
+
+/// Execute a block, with `input` being the canonical serialisation of the block. Returns the
+/// empty vector.
+pub fn execute_block(mut input: &[u8]) -> Vec<u8> {
+	runtime::system::internal::execute_block(Block::from_slice(&mut input).unwrap());
+	Vec::new()
+}
+
+/// Execute a given, serialised, transaction. Returns the empty vector.
+pub fn execute_transaction(mut input: &[u8]) -> Vec<u8> {
+	let header = Header::from_slice(&mut input).unwrap();
+	let utx = UncheckedTransaction::from_slice(&mut input).unwrap();
+	let header = runtime::system::internal::execute_transaction(utx, header);
+	header.to_vec()
+}
+
+/// Execute a given, serialised, transaction. Returns the empty vector.
+pub fn finalise_block(mut input: &[u8]) -> Vec<u8> {
+	let header = Header::from_slice(&mut input).unwrap();
+	let header = runtime::system::internal::finalise_block(header);
+	header.to_vec()
+}
+
+/// Run whatever tests we have.
+pub fn run_tests(mut input: &[u8]) -> Vec<u8> {
+	use runtime_io::print;
+
+	print("run_tests...");
+	let block = Block::from_slice(&mut input).unwrap();
+	print("deserialised block.");
+	let stxs = block.transactions.iter().map(Slicable::to_vec).collect::<Vec<_>>();
+	print("reserialised transactions.");
+	[stxs.len() as u8].to_vec()
+}
+
+impl_stubs!(execute_block, execute_transaction, finalise_block, run_tests);

substrate/polkadot-runtime/src/runtime/consensus.rs

@@ -0,0 +1,48 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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 support::storage::unhashed::StorageVec;
+use polkadot_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/polkadot-runtime/src/runtime/governance.rs

@@ -0,0 +1,370 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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 support::storage;
+use polkadot_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 polkadot_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 support::{one, two, with_env};
+	use polkadot_primitives::{AccountId, Proposal};
+	use runtime::{staking, session};
+
+	fn new_test_ext() -> TestExternalities {
+		let one = one();
+		let two = two();
+		let three = [3u8; 32];
+
+		TestExternalities { storage: map![
+			twox_128(APPROVALS_REQUIRED).to_vec() => vec![].join(&667u32),
+			twox_128(b"ses:len").to_vec() => vec![].join(&1u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].join(&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![].join(&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![].join(&1u64),
+			twox_128(b"sta:vac").to_vec() => vec![].join(&3u64),
+			twox_128(b"sta:era").to_vec() => vec![].join(&1u64)
+		], }
+	}
+
+	#[test]
+	fn majority_voting_should_work() {
+		let one = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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 = one();
+		let two = two();
+		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/polkadot-runtime/src/runtime/mod.rs

@@ -0,0 +1,34 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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;
+#[allow(unused)]
+pub mod parachains;
+
+// TODO: polkadao

substrate/polkadot-runtime/src/runtime/parachains.rs

@@ -0,0 +1,142 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Main parachains logic. For now this is just the determination of which validators do what.
+
+use rstd::prelude::*;
+use runtime_io::mem;
+use codec::{Slicable, Joiner};
+use support::{Hashable, with_env, storage};
+use runtime::session;
+
+const PARACHAIN_COUNT: &[u8] = b"par:cou";
+
+/// Identifier for a chain, either one of a number of parachains or the relay chain.
+#[derive(Copy, Clone, PartialEq)]
+#[cfg_attr(test, derive(Debug))]
+pub enum Chain {
+	/// The relay chain.
+	Relay,
+	/// A parachain of the given index.
+	Parachain(u32),
+}
+
+/// The duty roster specifying what jobs each validator must do.
+#[derive(Clone, PartialEq)]
+#[cfg_attr(test, derive(Default, Debug))]
+pub struct DutyRoster {
+	/// Lookup from validator index to chain on which that validator has a duty to validate.
+	pub validator_duty: Vec<Chain>,
+	/// Lookup from validator index to chain on which that validator has a duty to guarantee
+	/// availability.
+	pub guarantor_duty: Vec<Chain>,
+}
+
+/// Get the number of parachains registered at present.
+pub fn parachain_count() -> u32 {
+	storage::get_or(PARACHAIN_COUNT, 0)
+}
+
+/// Calculate the current block's duty roster.
+pub fn calculate_duty_roster() -> DutyRoster {
+	let parachain_count = parachain_count();
+	let validator_count = session::validator_count() as u32;
+	let validators_per_parachain = (validator_count - 1) / parachain_count;
+
+	let mut roles_val = (0..validator_count).map(|i| match i {
+		i if i < parachain_count * validators_per_parachain => Chain::Parachain(i / validators_per_parachain as u32),
+		_ => Chain::Relay,
+	}).collect::<Vec<_>>();
+	let mut roles_gua = roles_val.clone();
+
+	let h = with_env(|e| e.parent_hash.clone());
+	let mut seed = Vec::<u8>::new().join(&h).join(b"validator_role_pairs").blake2_256();
+
+	// shuffle
+	for i in 0..(validator_count - 1) {
+		// 8 bytes of entropy used per cycle, 32 bytes entropy per hash
+		let offset = (i * 8 % 32) as usize;
+
+		// number of roles remaining to select from.
+		let remaining = (validator_count - i) as usize;
+
+		// 4 * 2 32-bit ints per 256-bit seed.
+		let val_index = u32::from_slice(&mut &seed[offset..offset + 4]).expect("using 4 bytes for a 32-bit quantity") as usize % remaining;
+		let gua_index = u32::from_slice(&mut &seed[offset + 4..offset + 8]).expect("using 4 bytes for a 32-bit quantity") as usize % remaining;
+
+		if offset == 24 {
+			// into the last 8 bytes - rehash to gather new entropy
+			seed = seed.blake2_256();
+		}
+
+		// exchange last item with randomly chosen first.
+		roles_val.swap(remaining - 1, val_index);
+		roles_gua.swap(remaining - 1, gua_index);
+	}
+
+	DutyRoster {
+		validator_duty: roles_val,
+		guarantor_duty: roles_gua,
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{KeyedVec, Joiner};
+	use support::{one, two, with_env};
+	use runtime::{consensus, session};
+
+	fn simple_setup() -> TestExternalities {
+		TestExternalities { storage: map![
+			twox_128(b"ses:val:len").to_vec() => vec![].join(&8u32),
+			twox_128(b"par:cou").to_vec() => vec![].join(&2u32)
+		], }
+	}
+
+	#[test]
+	fn should_work() {
+		let mut t = simple_setup();
+		with_externalities(&mut t, || {
+			let check_roster = |duty_roster: &DutyRoster| {
+				assert_eq!(duty_roster.validator_duty.len(), 8);
+				assert_eq!(duty_roster.guarantor_duty.len(), 8);
+				for i in 0..2 {
+					assert_eq!(duty_roster.validator_duty.iter().filter(|&&j| j == Chain::Parachain(i)).count(), 3);
+					assert_eq!(duty_roster.guarantor_duty.iter().filter(|&&j| j == Chain::Parachain(i)).count(), 3);
+				}
+				assert_eq!(duty_roster.validator_duty.iter().filter(|&&j| j == Chain::Relay).count(), 2);
+				assert_eq!(duty_roster.guarantor_duty.iter().filter(|&&j| j == Chain::Relay).count(), 2);
+			};
+
+			with_env(|e| e.parent_hash = [0u8; 32].into());
+			let duty_roster_0 = calculate_duty_roster();
+			check_roster(&duty_roster_0);
+
+			with_env(|e| e.parent_hash = [1u8; 32].into());
+			let duty_roster_1 = calculate_duty_roster();
+			check_roster(&duty_roster_1);
+			assert!(duty_roster_0 != duty_roster_1);
+
+			with_env(|e| e.parent_hash = [2u8; 32].into());
+			let duty_roster_2 = calculate_duty_roster();
+			check_roster(&duty_roster_2);
+			assert!(duty_roster_0 != duty_roster_2);
+			assert!(duty_roster_1 != duty_roster_2);
+		});
+	}
+}

substrate/polkadot-runtime/src/runtime/session.rs

@@ -0,0 +1,249 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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 support::{storage, StorageVec};
+use polkadot_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 authorities. These are the session keys.
+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 support::{one, two, with_env};
+	use polkadot_primitives::AccountId;
+	use runtime::{consensus, session};
+
+	fn simple_setup() -> TestExternalities {
+		TestExternalities { storage: map![
+			twox_128(SESSION_LENGTH).to_vec() => vec![].join(&2u64),
+			// the validators (10, 20, ...)
+			twox_128(b"ses:val:len").to_vec() => vec![].join(&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![].join(&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/polkadot-runtime/src/runtime/staking.rs

@@ -0,0 +1,406 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Staking manager: Handles balances and periodically determines the best set of validators.
+
+use rstd::prelude::*;
+use runtime_io::cell::RefCell;
+use runtime_io::print;
+use codec::KeyedVec;
+use support::{storage, StorageVec};
+use polkadot_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 support::{one, two, with_env};
+	use polkadot_primitives::AccountId;
+	use runtime::{staking, session};
+
+	#[test]
+	fn staking_should_work() {
+		let one = one();
+		let two = two();
+		let three = [3u8; 32];
+		let four = [4u8; 32];
+
+		let mut t = TestExternalities { storage: map![
+			twox_128(b"ses:len").to_vec() => vec![].join(&1u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].join(&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![].join(&2u64),
+			twox_128(VALIDATOR_COUNT).to_vec() => vec![].join(&2u32),
+			twox_128(BONDING_DURATION).to_vec() => vec![].join(&3u64),
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&10u64),
+			twox_128(&two.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&20u64),
+			twox_128(&three.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&30u64),
+			twox_128(&four.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&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 { storage: map![
+			twox_128(b"ses:len").to_vec() => vec![].join(&1u64),
+			twox_128(SESSIONS_PER_ERA).to_vec() => vec![].join(&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 = one();
+		let two = two();
+
+		let mut t = TestExternalities { storage: map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&42u64)
+		], };
+
+		with_externalities(&mut t, || {
+			assert_eq!(balance(&one), 42);
+			assert_eq!(balance(&two), 0);
+		});
+	}
+
+	#[test]
+	fn staking_balance_transfer_works() {
+		let one = one();
+		let two = two();
+
+		let mut t = TestExternalities { storage: map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&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 = one();
+		let two = two();
+
+		let mut t = TestExternalities { storage: map![
+			twox_128(&one.to_keyed_vec(BALANCE_OF)).to_vec() => vec![].join(&111u64)
+		], };
+
+		with_externalities(&mut t, || {
+			stake(&one);
+			transfer(&one, &two, 69);
+		});
+	}
+}

substrate/polkadot-runtime/src/runtime/system.rs

@@ -0,0 +1,352 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  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 runtime_io::{mem, storage_root, enumerated_trie_root};
+use codec::{KeyedVec, Slicable};
+use support::{Hashable, storage, with_env};
+use polkadot_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 {
+		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::to_vec).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 support::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) {}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use super::internal::*;
+
+	use runtime_io::{with_externalities, twox_128, TestExternalities};
+	use codec::{Joiner, KeyedVec, Slicable};
+	use support::{StaticHexInto, HexDisplay, one, two};
+	use polkadot_primitives::{Header, Digest, UncheckedTransaction, Transaction, Function};
+	use runtime::staking;
+
+	#[test]
+	fn staking_balance_transfer_dispatch_works() {
+		let one = one();
+		let two = two();
+
+		let mut t = TestExternalities { storage: 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: "5f9832c5a4a39e2dd4a3a0c5b400e9836beb362cb8f7d845a8291a2ae6fe366612e080e4acd0b5a75c3d0b6ee69614a68fb63698c1e76bf1f2dcd8fa617ddf05".parse().unwrap(),
+		};
+
+		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 = one();
+		let two = two();
+		let three = [3u8; 32];
+
+		TestExternalities { storage: map![
+			twox_128(&0u64.to_keyed_vec(b"sys:old:")).to_vec() => [69u8; 32].to_vec(),
+			twox_128(b"gov:apr").to_vec() => vec![].join(&667u32),
+			twox_128(b"ses:len").to_vec() => vec![].join(&2u64),
+			twox_128(b"ses:val:len").to_vec() => vec![].join(&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![].join(&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![].join(&2u64),
+			twox_128(b"sta:vac").to_vec() => vec![].join(&3u64),
+			twox_128(b"sta:era").to_vec() => vec![].join(&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 = one();
+		let two = two();
+
+		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 = one();
+		let two = two();
+
+		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 = one();
+		let two = two();
+
+		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/polkadot-runtime/src/runtime/timestamp.rs

@@ -0,0 +1,60 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Timestamp manager: just handles the current timestamp.
+
+use 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 { storage: map![
+			twox_128(CURRENT_TIMESTAMP).to_vec() => vec![].join(&42u64)
+		], };
+
+		with_externalities(&mut t, || {
+			assert_eq!(get(), 42);
+			set(69);
+			assert_eq!(get(), 69);
+		});
+	}
+}

substrate/polkadot-runtime/src/support/environment.rs

@@ -0,0 +1,82 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Environment API: Allows certain information to be accessed throughout the runtime.
+
+use runtime_io::boxed::Box;
+use runtime_io::mem;
+use runtime_io::cell::RefCell;
+use runtime_io::rc::Rc;
+
+use polkadot_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/polkadot-runtime/src/support/hashable.rs

@@ -0,0 +1,38 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Hashable trait.
+
+use codec::Slicable;
+use runtime_io::{blake2_256, twox_128, twox_256};
+
+pub trait Hashable: Sized {
+	fn blake2_256(&self) -> [u8; 32];
+	fn twox_128(&self) -> [u8; 16];
+	fn twox_256(&self) -> [u8; 32];
+}
+
+impl<T: Slicable> Hashable for T {
+	fn blake2_256(&self) -> [u8; 32] {
+		blake2_256(&self.to_vec())
+	}
+	fn twox_128(&self) -> [u8; 16] {
+		twox_128(&self.to_vec())
+	}
+	fn twox_256(&self) -> [u8; 32] {
+		twox_256(&self.to_vec())
+	}
+}

substrate/polkadot-runtime/src/support/mod.rs

@@ -0,0 +1,36 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Support code for the runtime.
+
+mod environment;
+pub mod storage;
+mod hashable;
+#[cfg(feature = "std")]
+mod statichex;
+#[macro_use]
+#[cfg(feature = "std")]
+mod testing;
+
+pub use self::environment::with_env;
+pub use self::storage::StorageVec;
+pub use self::hashable::Hashable;
+
+#[cfg(feature = "std")]
+pub use self::statichex::{StaticHexConversion, StaticHexInto};
+
+#[cfg(feature = "std")]
+pub use self::testing::{AsBytesRef, HexDisplay, one, two};

substrate/polkadot-runtime/src/support/statichex.rs

@@ -0,0 +1,61 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Interpret a static string of hex as a desired type.
+
+use rustc_hex::FromHex;
+
+/// Trait to allow conversion from a static hex string to an instance.
+pub trait StaticHexConversion: Sized {
+	/// Convert the static str into Self. Use just like `From::from`.
+	fn from_static_hex(hex: &'static str) -> Self;
+}
+
+macro_rules! impl_sizes {
+	( $( $t:expr ),* ) => { $(
+		impl StaticHexConversion for [u8; $t] {
+			fn from_static_hex(hex: &'static str) -> Self {
+				let mut r = [0u8; $t];
+				r.copy_from_slice(&FromHex::from_hex(hex).unwrap());
+				r
+			}
+		}
+	)* }
+}
+
+impl StaticHexConversion for Vec<u8> {
+	fn from_static_hex(hex: &'static str) -> Self {
+		FromHex::from_hex(hex).unwrap()
+	}
+}
+
+impl_sizes!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+	17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+	33, 34, 35, 36, 37, 38, 39, 40, 451, 42, 43, 44, 45, 46, 47, 48,
+	56, 64, 80, 96, 112, 128);
+
+/// Trait to allow converting from itself (only implemented for a static str) into some useful
+/// type (which must implement `StaticHexConversion`).
+pub trait StaticHexInto {
+	/// Convert self (i.e. a static str) into the appropriate type. Use just like `Into::into`.
+	fn convert<T: StaticHexConversion>(self) -> T;
+}
+
+impl StaticHexInto for &'static str {
+	fn convert<T: StaticHexConversion>(self) -> T {
+		T::from_static_hex(self)
+	}
+}

substrate/polkadot-runtime/src/support/storage.rs

@@ -0,0 +1,350 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Stuff to do with the runtime's storage.
+
+use rstd::prelude::*;
+use runtime_io::{self, twox_128};
+use codec::{Slicable, KeyedVec};
+
+// TODO: consider using blake256 to avoid possible preimage attack.
+
+/// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
+pub fn get<T: Slicable + Sized>(key: &[u8]) -> Option<T> {
+	let raw = runtime_io::storage(&twox_128(key)[..]);
+	Slicable::from_slice(&mut &raw[..])
+}
+
+/// Return the value of the item in storage under `key`, or the type's default if there is no
+/// explicit entry.
+pub fn get_or_default<T: Slicable + Sized + Default>(key: &[u8]) -> T {
+	get(key).unwrap_or_else(Default::default)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry.
+pub fn get_or<T: Slicable + Sized>(key: &[u8], default_value: T) -> T {
+	get(key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry.
+pub fn get_or_else<T: Slicable + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+	get(key).unwrap_or_else(default_value)
+}
+
+/// Please `value` in storage under `key`.
+pub fn put<T: Slicable>(key: &[u8], value: &T) {
+	value.as_slice_then(|slice| runtime_io::set_storage(&twox_128(key)[..], slice));
+}
+
+/// Please `value` in storage under `key`.
+pub fn place<T: Slicable>(key: &[u8], value: T) {
+	value.as_slice_then(|slice| runtime_io::set_storage(&twox_128(key)[..], slice));
+}
+
+/// Remove `key` from storage, returning its value if it had an explicit entry or `None` otherwise.
+pub fn take<T: Slicable + Sized>(key: &[u8]) -> Option<T> {
+	let r = get(key);
+	if r.is_some() {
+		kill(key);
+	}
+	r
+}
+
+/// Remove `key` from storage, returning its value, or, if there was no explicit entry in storage,
+/// the default for its type.
+pub fn take_or_default<T: Slicable + Sized + Default>(key: &[u8]) -> T {
+	take(key).unwrap_or_else(Default::default)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or<T: Slicable + Sized>(key: &[u8], default_value: T) -> T {
+	take(key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or_else<T: Slicable + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+	take(key).unwrap_or_else(default_value)
+}
+
+/// Check to see if `key` has an explicit entry in storage.
+pub fn exists(key: &[u8]) -> bool {
+	let mut x = [0u8; 1];
+	runtime_io::read_storage(&twox_128(key)[..], &mut x[..], 0) >= 1
+}
+
+/// Ensure `key` has no explicit entry in storage.
+pub fn kill(key: &[u8]) {
+	runtime_io::set_storage(&twox_128(key)[..], b"");
+}
+
+/// Get a Vec of bytes from storage.
+pub fn get_raw(key: &[u8]) -> Vec<u8> {
+	runtime_io::storage(&twox_128(key)[..])
+}
+
+/// Put a raw byte slice into storage.
+pub fn put_raw(key: &[u8], value: &[u8]) {
+	runtime_io::set_storage(&twox_128(key)[..], value)
+}
+
+/// A trait to conveniently store a vector of storable data.
+// TODO: add iterator support
+pub trait StorageVec {
+	type Item: Default + Sized + Slicable;
+	const PREFIX: &'static [u8];
+
+	/// Get the current set of items.
+	fn items() -> Vec<Self::Item> {
+		(0..Self::count()).into_iter().map(Self::item).collect()
+	}
+
+	/// Set the current set of items.
+	fn set_items(items: &[Self::Item]) {
+		Self::set_count(items.len() as u32);
+		items.iter().enumerate().for_each(|(v, ref i)| Self::set_item(v as u32, i));
+	}
+
+	fn set_item(index: u32, item: &Self::Item) {
+		if index < Self::count() {
+			put(&index.to_keyed_vec(Self::PREFIX), item);
+		}
+	}
+
+	fn item(index: u32) -> Self::Item {
+		get_or_default(&index.to_keyed_vec(Self::PREFIX))
+	}
+
+	fn set_count(count: u32) {
+		(count..Self::count()).for_each(|i| Self::set_item(i, &Self::Item::default()));
+		put(&b"len".to_keyed_vec(Self::PREFIX), &count);
+	}
+
+	fn count() -> u32 {
+		get_or_default(&b"len".to_keyed_vec(Self::PREFIX))
+	}
+}
+
+pub mod unhashed {
+	use super::{runtime_io, Slicable, KeyedVec, Vec};
+
+	/// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
+	pub fn get<T: Slicable + Sized>(key: &[u8]) -> Option<T> {
+		let raw = runtime_io::storage(key);
+		T::from_slice(&mut &raw[..])
+	}
+
+	/// Return the value of the item in storage under `key`, or the type's default if there is no
+	/// explicit entry.
+	pub fn get_or_default<T: Slicable + Sized + Default>(key: &[u8]) -> T {
+		get(key).unwrap_or_else(Default::default)
+	}
+
+	/// Return the value of the item in storage under `key`, or `default_value` if there is no
+	/// explicit entry.
+	pub fn get_or<T: Slicable + Sized>(key: &[u8], default_value: T) -> T {
+		get(key).unwrap_or(default_value)
+	}
+
+	/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+	/// explicit entry.
+	pub fn get_or_else<T: Slicable + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+		get(key).unwrap_or_else(default_value)
+	}
+
+	/// Please `value` in storage under `key`.
+	pub fn put<T: Slicable>(key: &[u8], value: &T) {
+		value.as_slice_then(|slice| runtime_io::set_storage(key, slice));
+	}
+
+	/// Please `value` in storage under `key`.
+	pub fn place<T: Slicable>(key: &[u8], value: T) {
+		value.as_slice_then(|slice| runtime_io::set_storage(key, slice));
+	}
+
+	/// Remove `key` from storage, returning its value if it had an explicit entry or `None` otherwise.
+	pub fn take<T: Slicable + Sized>(key: &[u8]) -> Option<T> {
+		let r = get(key);
+		if r.is_some() {
+			kill(key);
+		}
+		r
+	}
+
+	/// Remove `key` from storage, returning its value, or, if there was no explicit entry in storage,
+	/// the default for its type.
+	pub fn take_or_default<T: Slicable + Sized + Default>(key: &[u8]) -> T {
+		take(key).unwrap_or_else(Default::default)
+	}
+
+	/// Return the value of the item in storage under `key`, or `default_value` if there is no
+	/// explicit entry. Ensure there is no explicit entry on return.
+	pub fn take_or<T: Slicable + Sized>(key: &[u8], default_value: T) -> T {
+		take(key).unwrap_or(default_value)
+	}
+
+	/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+	/// explicit entry. Ensure there is no explicit entry on return.
+	pub fn take_or_else<T: Slicable + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+		take(key).unwrap_or_else(default_value)
+	}
+
+	/// Check to see if `key` has an explicit entry in storage.
+	pub fn exists(key: &[u8]) -> bool {
+		let mut x = [0u8; 1];
+		runtime_io::read_storage(key, &mut x[..], 0) >= 1
+	}
+
+	/// Ensure `key` has no explicit entry in storage.
+	pub fn kill(key: &[u8]) {
+		runtime_io::set_storage(key, b"");
+	}
+
+	/// Get a Vec of bytes from storage.
+	pub fn get_raw(key: &[u8]) -> Vec<u8> {
+		runtime_io::storage(key)
+	}
+
+	/// Put a raw byte slice into storage.
+	pub fn put_raw(key: &[u8], value: &[u8]) {
+		runtime_io::set_storage(key, value)
+	}
+
+	/// A trait to conveniently store a vector of storable data.
+	// TODO: add iterator support
+	pub trait StorageVec {
+		type Item: Default + Sized + Slicable;
+		const PREFIX: &'static [u8];
+
+		/// Get the current set of items.
+		fn items() -> Vec<Self::Item> {
+			(0..Self::count()).into_iter().map(Self::item).collect()
+		}
+
+		/// Set the current set of items.
+		fn set_items(items: &[Self::Item]) {
+			Self::set_count(items.len() as u32);
+			items.iter().enumerate().for_each(|(v, ref i)| Self::set_item(v as u32, i));
+		}
+
+		fn set_item(index: u32, item: &Self::Item) {
+			if index < Self::count() {
+				put(&index.to_keyed_vec(Self::PREFIX), item);
+			}
+		}
+
+		fn item(index: u32) -> Self::Item {
+			get_or_default(&index.to_keyed_vec(Self::PREFIX))
+		}
+
+		fn set_count(count: u32) {
+			(count..Self::count()).for_each(|i| Self::set_item(i, &Self::Item::default()));
+			put(&b"len".to_keyed_vec(Self::PREFIX), &count);
+		}
+
+		fn count() -> u32 {
+			get_or_default(&b"len".to_keyed_vec(Self::PREFIX))
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::collections::HashMap;
+	use support::HexDisplay;
+	use runtime_io::{storage, twox_128, TestExternalities, with_externalities};
+
+	#[test]
+	fn integers_can_be_stored() {
+		let mut t = TestExternalities { storage: HashMap::new(), };
+		with_externalities(&mut t, || {
+			let x = 69u32;
+			put(b":test", &x);
+			let y: u32 = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+		with_externalities(&mut t, || {
+			let x = 69426942i64;
+			put(b":test", &x);
+			let y: i64 = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+	}
+
+	#[test]
+	fn bools_can_be_stored() {
+		let mut t = TestExternalities { storage: HashMap::new(), };
+		with_externalities(&mut t, || {
+			let x = true;
+			put(b":test", &x);
+			let y: bool = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+
+		with_externalities(&mut t, || {
+			let x = false;
+			put(b":test", &x);
+			let y: bool = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+	}
+
+	#[test]
+	fn vecs_can_be_retrieved() {
+		let mut t = TestExternalities { storage: HashMap::new(), };
+		with_externalities(&mut t, || {
+			runtime_io::set_storage(&twox_128(b":test"), b"\x0b\0\0\0Hello world");
+			let x = b"Hello world".to_vec();
+			println!("Hex: {}", HexDisplay::from(&storage(&twox_128(b":test"))));
+			let y = get::<Vec<u8>>(b":test").unwrap();
+			assert_eq!(x, y);
+
+		});
+	}
+
+	#[test]
+	fn vecs_can_be_stored() {
+		let mut t = TestExternalities { storage: HashMap::new(), };
+		let x = b"Hello world".to_vec();
+
+		with_externalities(&mut t, || {
+			put(b":test", &x);
+		});
+
+		println!("Ext is {:?}", t);
+		with_externalities(&mut t, || {
+			println!("Hex: {}", HexDisplay::from(&storage(&twox_128(b":test"))));
+			let y: Vec<u8> = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+	}
+
+	#[test]
+	fn proposals_can_be_stored() {
+		use polkadot_primitives::Proposal;
+		let mut t = TestExternalities { storage: HashMap::new(), };
+		with_externalities(&mut t, || {
+			let x = Proposal::StakingSetSessionsPerEra(25519);
+			put(b":test", &x);
+			let y: Proposal = get(b":test").unwrap();
+			assert_eq!(x, y);
+		});
+	}
+}

substrate/polkadot-runtime/src/support/testing.rs

@@ -0,0 +1,83 @@
+// Copyright 2017 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot 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.
+
+// Polkadot 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 Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Testing helpers.
+
+use polkadot_primitives::AccountId;
+use super::statichex::StaticHexInto;
+
+#[macro_export]
+macro_rules! map {
+	($( $name:expr => $value:expr ),*) => (
+		vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+	)
+}
+
+/// One account (to which we know the secret key).
+pub fn one() -> AccountId {
+	"2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee".convert()
+}
+/// Another account (secret key known).
+pub fn two() -> AccountId {
+	"d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a".convert()
+}
+
+/// Hex display, this time for no_std. See main codebase for documentation.
+pub struct HexDisplay<'a>(&'a [u8]);
+
+impl<'a> HexDisplay<'a> {
+	/// See main codebase for documentation.
+	pub fn from(d: &'a AsBytesRef) -> Self { HexDisplay(d.as_bytes_ref()) }
+}
+
+impl<'a> ::std::fmt::Display for HexDisplay<'a> {
+	fn fmt(&self, fmtr: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+		for byte in self.0 {
+			try!( fmtr.write_fmt(format_args!("{:02x}", byte)));
+		}
+		Ok(())
+	}
+}
+
+/// See main codebase for documentation.
+pub trait AsBytesRef {
+	/// See main codebase for documentation.
+	fn as_bytes_ref(&self) -> &[u8];
+}
+
+impl AsBytesRef for [u8] {
+	fn as_bytes_ref(&self) -> &[u8] { &self }
+}
+
+impl<'a> AsBytesRef for &'a[u8] {
+	fn as_bytes_ref(&self) -> &[u8] { self }
+}
+
+impl AsBytesRef for Vec<u8> {
+	fn as_bytes_ref(&self) -> &[u8] { &self[..] }
+}
+
+macro_rules! impl_non_endians {
+	( $( $t:ty ),* ) => { $(
+		impl AsBytesRef for $t {
+			fn as_bytes_ref(&self) -> &[u8] { &self[..] }
+		}
+	)* }
+}
+
+impl_non_endians!([u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8],
+	[u8; 10], [u8; 12], [u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40],
+	[u8; 48], [u8; 56], [u8; 64], [u8; 80], [u8; 96], [u8; 112], [u8; 128]);

substrate/polkadot-runtime/wasm/Cargo.lock

@@ -0,0 +1,879 @@
+[[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 = "ed25519"
+version = "0.1.0"
+dependencies = [
+ "ring 0.12.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-hex 1.0.0 (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 = "polkadot-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 = "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 = "runtime-polkadot"
+version = "0.1.0"
+dependencies = [
+ "polkadot-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",
+]
+
+[[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",
+ "pwasm-alloc 0.1.0",
+ "pwasm-libc 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 = [
+ "rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[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/polkadot-runtime/wasm/Cargo.toml

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

substrate/polkadot-runtime/wasm/build.sh

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

substrate/polkadot-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/polkadot-runtime/wasm/src

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

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

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/crunchy-428ca79f7094ae1b/lib-crunchy-428ca79f7094ae1b

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/crunchy-7afe3ee0284c8f65/build-script-build_script_build-7afe3ee0284c8f65

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/crunchy-aa6f78c4ab60ae0c/build

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/fixed-hash-1efcfb7c375dbdea/lib-fixed_hash-1efcfb7c375dbdea

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-284228216c0862ab/build-script-build_script_build-284228216c0862ab

@@ -0,0 +1 @@
+2a7515528f889773

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-284228216c0862ab/build-script-build_script_build-284228216c0862ab.json

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

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-5595e35c8d1d0375/lib-pwasm_alloc-5595e35c8d1d0375

@@ -0,0 +1 @@
+75393c3c5de927c2

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-5595e35c8d1d0375/lib-pwasm_alloc-5595e35c8d1d0375.json

@@ -0,0 +1 @@
+{"rustc":2076919156954903493,"features":"[]","target":16381687520801172552,"profile":731176819336294830,"deps":[["pwasm-libc v0.1.0 (file:///Users/gav/Core/polkadot/pwasm-libc)",2590986117911703621]],"local":[{"MtimeBased":[[1518042634,737180368],"/Users/gav/Core/polkadot/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-5595e35c8d1d0375/dep-lib-pwasm_alloc-5595e35c8d1d0375"]}],"rustflags":[]}

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-b07d4b56ebd67f50/build

@@ -0,0 +1 @@
+61589799b5bfcd78

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-alloc-b07d4b56ebd67f50/build.json

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

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-libc-ee4fc689433c70fc/lib-pwasm_libc-ee4fc689433c70fc

@@ -0,0 +1 @@
+457018882508f523

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/pwasm-libc-ee4fc689433c70fc/lib-pwasm_libc-ee4fc689433c70fc.json

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

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

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/rustc_version-5b6a601163a6fa82/lib-rustc_version-5b6a601163a6fa82

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/semver-c1ec2df066d48dfc/lib-semver-c1ec2df066d48dfc

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/semver-parser-76e51e73206527e9/lib-semver_parser-76e51e73206527e9

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/serde-133bbc10deb4b2bf/lib-serde-133bbc10deb4b2bf

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-30f9d13785183581/build

@@ -0,0 +1 @@
+f6923b777ce33247

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-30f9d13785183581/build.json

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

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a912dae9a71befc0/build-script-build_script_build-a912dae9a71befc0

@@ -0,0 +1 @@
+7ab680d3aa1d3f04

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-io-a912dae9a71befc0/build-script-build_script_build-a912dae9a71befc0.json

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

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-0e3391d038d16e52/build

@@ -0,0 +1 @@
+7898f71b5707e68f

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-0e3391d038d16e52/build.json

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

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-61d54fefa7496f50/build-script-build_script_build-61d54fefa7496f50

@@ -0,0 +1 @@
+d58d98706c38c30b

substrate/polkadot-runtime/wasm/target/debug/.fingerprint/substrate-runtime-std-61d54fefa7496f50/build-script-build_script_build-61d54fefa7496f50.json

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

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

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/uint-07239eb1916014b7/build-script-build_script_build-07239eb1916014b7

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

substrate/polkadot-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/polkadot-runtime/wasm/target/debug/.fingerprint/uint-d3e5c9930d5fba2d/build

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

substrate/polkadot-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/polkadot-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/polkadot-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>>());
+        }
+    }
+}

substrate/polkadot-runtime/wasm/target/debug/build/pwasm-alloc-284228216c0862ab/build_script_build-284228216c0862ab.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-284228216c0862ab</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/polkadot-runtime/wasm/target/debug/build/substrate-runtime-io-a912dae9a71befc0/build_script_build-a912dae9a71befc0.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-a912dae9a71befc0</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>