Dump genesis to JSON file (#218)

* Merge remote-tracking branch 'origin/master' into gav-xts-dont-panic

* Update wasm.

* consensus, session and staking all panic-safe.

* Democracy doesn't panic in apply.

* Fix tests.

* Extra helper macro, council depanicked.

* Fix one test.

* Fix up all council tests. No panics!

* Council voting depanicked.

* Dispatch returns result.

* session & staking tests updated

* Fix democracy tests.

* Fix council tests.

* Fix up polkadot parachains in runtime

* Fix borked merge

* More Slicable support

Support general `Option` and array types.

* Basic storage types.

* Existential deposit for contract creation

* Basic implemnetation along with removals

* Fix tests.

* externalities builder fix.

* Tests.

* Fix up the runtime.

* Fix tests.

* Add generic `Address` type.

* Initial function integration of Address into Extrinsic.

* Fix build

* All tests compile.

* Fix (some) tests.

* Fix signing.

* Push error.

* transfer can accept Address

* Make Address generic over AccountIndex

* Fix test

* Make Council use Address for dispatch.

* Fix build

* Bend over backwards to support braindead derive.

* Repot some files.

* Fix tests.

* Fix grumbles

* Remove Default bound

* Fix build for new nightly.

* Make `apply_extrinsic` never panic, return useful Result.

* More merge hell

* Doesn't build, but might do soon

* Serde woes

* get substrate-runtime-staking compiling

* Polkadot builds again!

* Fix all build.

* Fix tests & binaries.

* Reserve some extra initial byte values of address for future format changes

* Make semantic of `ReservedBalance` clear.

* Fix panic handler.

* Integrate other balance transformations into the new model

Fix up staking tests.

* Fix runtime tests.

* Fix panic build.

* Tests for demonstrating interaction between balance types.

* Repot some runtime code

* Fix checkedblock in non-std builds

* Get rid of `DoLookup` phantom.

* Attempt to make transaction_pool work with lookups.

* Remove vscode settings

* New attempt at making transaction pool work.

* It builds again!

* --all builds

* Fix tests.

* New build.

* Test account nonce reset.

* polkadot transaction pool tests/framework.

* Initial draft (working).

* Address grumbles.

* Revert bad `map_or`

* Rebuild binaries, workaround.

* Avoid checking in vscode

* reconnecting, shared, slog

* CLI options for name and telemetry url

* ensure telemetry url imples enabled

* Avoid casting to usize early.

* Provide on-connect event for session message

* Better port

* heartbeat and some renaming

* transaction pool stuff

* minor renaming.

* report telemetry

* cleanups.

* Fix for previous cleanup

* dump genesis, dev mode, renaming

* Rework chain spec/config &c. to allow for genesis file loading.

* Avoid producing genesis storage when unneeded

* Allow reading JSON genesis state dumps

* tests work again

* better logging.

* Fix wasm build.

* Introduce PoC-1 spec

* Made block message compatible with poc-1

* Squashed changes for dumping genesis block.

* Binaries.

* Made block message compatible with poc-1

* Remove dead code.

* Fix bad merge.

* Argument passing and returning values when invoking sandboxed funcs (#189)

* Fixed block download sequence (#223)

* Trie-based execution proof (#177)

* TrieBasedBackend

* trie tests

* redunant return_value removed

* use Trie::get_with to record trie proofs

* Relaying tx/blocks by light clients (#190)

* do not import external transactions into light tx pool

* do not announce blocks on light clients

* blocks_are_not_announced_by_light_nodes

substrate/substrate/client/db/src/lib.rs

@@ -46,6 +46,7 @@ use parking_lot::RwLock;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::bft::Justification;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, As, Hashing, HashingFor, Zero};
+use runtime_primitives::BuildStorage;
 use state_machine::backend::Backend as StateBackend;
 use state_machine::CodeExecutor;
 
@@ -61,21 +62,21 @@ pub struct DatabaseSettings {
 }
 
 /// Create an instance of db-backed client.
-pub fn new_client<E, F, Block>(
+pub fn new_client<E, S, Block>(
 	settings: DatabaseSettings,
 	executor: E,
-	genesis_builder: F,
+	genesis_storage: S,
 ) -> Result<client::Client<Backend<Block>, client::LocalCallExecutor<Backend<Block>, E>, Block>, client::error::Error>
 	where
 		Block: BlockT,
 		<Block::Header as HeaderT>::Number: As<u32>,
 		Block::Hash: Into<[u8; 32]>, // TODO: remove when patricia_trie generic.
 		E: CodeExecutor,
-		F: client::GenesisBuilder<Block>,
+		S: BuildStorage,
 {
 	let backend = Arc::new(Backend::new(&settings)?);
 	let executor = client::LocalCallExecutor::new(backend.clone(), executor);
-	Ok(client::Client::new(backend, executor, genesis_builder)?)
+	Ok(client::Client::new(backend, executor, genesis_storage)?)
 }
 
 mod columns {

substrate/substrate/client/src/client.rs

@@ -22,24 +22,19 @@ use parking_lot::{Mutex, RwLock};
 use primitives::AuthorityId;
 use runtime_primitives::{bft::Justification, generic::BlockId};
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, Zero, One};
+use runtime_primitives::BuildStorage;
 use primitives::storage::{StorageKey, StorageData};
-use codec::{Slicable};
+use codec::Slicable;
 use state_machine::{self, Ext, OverlayedChanges, Backend as StateBackend, CodeExecutor};
 
 use backend::{self, BlockImportOperation};
 use blockchain::{self, Info as ChainInfo, Backend as ChainBackend};
 use call_executor::{CallExecutor, LocalCallExecutor};
-use {error, in_mem, block_builder, runtime_io, bft};
+use {error, in_mem, block_builder, runtime_io, bft, genesis};
 
 /// Type that implements `futures::Stream` of block import events.
 pub type BlockchainEventStream<Block> = mpsc::UnboundedReceiver<BlockImportNotification<Block>>;
 
-/// Polkadot Client genesis block builder.
-pub trait GenesisBuilder<B: BlockT> {
-	/// Build genesis block.
-	fn build(self) -> (B::Header, Vec<(Vec<u8>, Vec<u8>)>);
-}
-
 /// Polkadot Client
 pub struct Client<B, E, Block> where Block: BlockT {
 	backend: Arc<B>,
@@ -146,18 +141,18 @@ impl<Block: BlockT> JustifiedHeader<Block> {
 }
 
 /// Create an instance of in-memory client.
-pub fn new_in_mem<E, F, Block>(
+pub fn new_in_mem<E, Block, S>(
 	executor: E,
-	genesis_builder: F
+	genesis_storage: S
 ) -> error::Result<Client<in_mem::Backend<Block>, LocalCallExecutor<in_mem::Backend<Block>, E>, Block>>
 	where
 		E: CodeExecutor,
-		F: GenesisBuilder<Block>,
+		S: BuildStorage,
 		Block: BlockT,
 {
 	let backend = Arc::new(in_mem::Backend::new());
 	let executor = LocalCallExecutor::new(backend.clone(), executor);
-	Client::new(backend, executor, genesis_builder)
+	Client::new(backend, executor, genesis_storage)
 }
 
 impl<B, E, Block: BlockT> Client<B, E, Block> where
@@ -167,20 +162,18 @@ impl<B, E, Block: BlockT> Client<B, E, Block> where
 	error::Error: From<<<B as backend::Backend<Block>>::State as StateBackend>::Error>,
 {
 	/// Creates new Polkadot Client with given blockchain and code executor.
-	pub fn new<F>(
+	pub fn new<S: BuildStorage>(
 		backend: Arc<B>,
 		executor: E,
-		genesis_builder: F,
-	) -> error::Result<Self>
-		where
-			F: GenesisBuilder<Block>
-	{
+		build_genesis_storage: S,
+	) -> error::Result<Self> {
 		if backend.blockchain().header(BlockId::Number(Zero::zero()))?.is_none() {
-			trace!("Empty database, writing genesis block");
-			let (genesis_header, genesis_store) = genesis_builder.build();
+			let genesis_storage = build_genesis_storage.build_storage();
+			let genesis_block = genesis::construct_genesis_block::<Block>(&genesis_storage);
+			info!("Initialising Genesis block/state (state: {}, header-hash: {})", genesis_block.header().state_root(), genesis_block.header().hash());
 			let mut op = backend.begin_operation(BlockId::Hash(Default::default()))?;
-			op.reset_storage(genesis_store.into_iter())?;
-			op.set_block_data(genesis_header, Some(vec![]), None, true)?;
+			op.reset_storage(genesis_storage.into_iter())?;
+			op.set_block_data(genesis_block.deconstruct().0, Some(vec![]), None, true)?;
 			backend.commit_operation(op)?;
 		}
 		Ok(Client {
@@ -493,7 +486,7 @@ mod tests {
 	#[test]
 	fn client_initialises_from_genesis_ok() {
 		let client = test_client::new();
-		let genesis_hash = client.block_hash(0).unwrap().unwrap();
+		let _genesis_hash = client.block_hash(0).unwrap().unwrap();
 
 		assert_eq!(client.using_environment(|| test_runtime::system::balance_of(Keyring::Alice.to_raw_public().into())).unwrap(), 1000);
 		assert_eq!(client.using_environment(|| test_runtime::system::balance_of(Keyring::Ferdie.to_raw_public().into())).unwrap(), 0);

substrate/substrate/client/src/genesis.rs

@@ -16,14 +16,14 @@
 
 //! Tool for creating the genesis block.
 
-use std::collections::HashMap;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT, Hashing as HashingT, Zero};
+use runtime_primitives::StorageMap;
 
 /// Create a genesis block, given the initial storage.
 pub fn construct_genesis_block<
 	Block: BlockT
 > (
-	storage: &HashMap<Vec<u8>, Vec<u8>>
+	storage: &StorageMap
 ) -> Block {
 	let state_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashingT>::trie_root(storage.clone().into_iter());
 	let extrinsics_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashingT>::trie_root(::std::iter::empty::<(&[u8], &[u8])>());

substrate/substrate/client/src/lib.rs

@@ -53,7 +53,7 @@ pub use client::{
 	new_in_mem,
 	BlockStatus, BlockOrigin, BlockchainEventStream, BlockchainEvents,
 	Client, ClientInfo, ChainHead,
-	ImportResult, GenesisBuilder,
+	ImportResult,
 };
 pub use blockchain::Info as ChainInfo;
 pub use call_executor::{

substrate/substrate/client/src/light.rs

@@ -25,10 +25,11 @@ use state_machine::backend::Backend as StateBackend;
 use runtime_primitives::generic::BlockId;
 use runtime_primitives::bft::Justification;
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT};
+use runtime_primitives::BuildStorage;
 use blockchain::{self, BlockStatus};
 use backend;
 use call_executor::{CallResult, RemoteCallExecutor, check_execution_proof};
-use client::{Client, GenesisBuilder};
+use client::Client;
 use error;
 use in_mem::Blockchain as InMemBlockchain;
 
@@ -228,18 +229,18 @@ pub fn new_light_backend<B: BlockT>() -> Arc<Backend<B>> {
 }
 
 /// Create an instance of light client.
-pub fn new_light<F, B, Block>(
+pub fn new_light<F, S, Block>(
 	backend: Arc<Backend<Block>>,
 	fetcher: Arc<F>,
-	genesis_builder: B,
+	genesis_storage: S,
 ) -> error::Result<Client<Backend<Block>, RemoteCallExecutor<Backend<Block>, F>, Block>>
 	where
 		F: Fetcher<Block>,
-		B: GenesisBuilder<Block>,
+		S: BuildStorage,
 		Block: BlockT,
 {
 	let executor = RemoteCallExecutor::new(backend.clone(), fetcher);
-	Client::new(backend, executor, genesis_builder)
+	Client::new(backend, executor, genesis_storage)
 }
 
 /// Create an instance of fetch data checker.

substrate/substrate/network/Cargo.toml

@@ -29,9 +29,9 @@ substrate-serializer = { path = "../../substrate/serializer" }
 substrate-runtime-support = { path = "../../substrate/runtime-support" }
 substrate-runtime-primitives = { path = "../../substrate/runtime/primitives" }
 substrate-bft = { path = "../../substrate/bft" }
+substrate-codec = { path = "../../substrate/codec" }
 
 [dev-dependencies]
 env_logger = "0.4"
-substrate-codec = { path = "../../substrate/codec" }
 substrate-keyring = { path = "../../substrate/keyring" }
 substrate-test-client = { path = "../../substrate/test-client" }

substrate/substrate/network/src/lib.rs

@@ -32,6 +32,7 @@ extern crate substrate_client as client;
 extern crate substrate_runtime_support as runtime_support;
 extern crate substrate_runtime_primitives as runtime_primitives;
 extern crate substrate_bft;
+extern crate substrate_codec as codec;
 extern crate serde;
 extern crate serde_json;
 extern crate futures;
@@ -42,7 +43,6 @@ extern crate ed25519;
 #[macro_use] extern crate error_chain;
 
 #[cfg(test)] extern crate env_logger;
-#[cfg(test)] extern crate substrate_codec as codec;
 #[cfg(test)] extern crate substrate_keyring as keyring;
 #[cfg(test)] extern crate substrate_test_client as test_client;
 

substrate/substrate/network/src/message.rs

@@ -19,7 +19,7 @@
 use runtime_primitives::traits::{Block as BlockT, Header as HeaderT};
 use service::Role as RoleFlags;
 
-pub use self::generic::{BlockAnnounce, RemoteCallRequest, ConsensusVote, SignedConsensusVote, FromBlock};
+pub use self::generic::{BlockAnnounce, RemoteCallRequest, ConsensusVote, SignedConsensusVote, FromBlock, Body};
 
 pub type RequestId = u64;
 
@@ -169,10 +169,44 @@ pub struct RemoteCallResponse {
 /// Generic types.
 pub mod generic {
 	use primitives::AuthorityId;
+	use codec::Slicable;
 	use runtime_primitives::bft::Justification;
 	use ed25519;
 
 	use super::{Role, BlockAttribute, RemoteCallResponse, RequestId, Transactions, Direction};
+
+	use primitives::bytes;
+
+	/// Emulates Poc-1 extrinsic primitive.
+	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+	pub struct V1Extrinsic(#[serde(with="bytes")] pub Vec<u8>);
+	// Alternative block format for poc-1 compatibility.
+	// TODO: remove this after poc-2
+	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
+	#[serde(untagged)]
+	/// Serialized block body type.
+	pub enum Body<Extrinsic> {
+		/// Poc-1. Extrinsics as bytes.
+		V1(Vec<V1Extrinsic>),
+		/// Poc-2 or later. A structured type.
+		Extrinsics(Vec<Extrinsic>),
+	}
+
+	impl<Extrinsic> Body<Extrinsic> where Extrinsic: Slicable {
+		/// Extracts extrinsic from the body.
+		pub fn to_extrinsics(self) -> Vec<Extrinsic> {
+			match self {
+				Body::Extrinsics(e) => e,
+				Body::V1(e) => {
+					e.into_iter().filter_map(|bytes| {
+						let bytes = bytes.0.encode();
+						Slicable::decode(&mut bytes.as_slice())
+					}).collect()
+				}
+			}
+		}
+	}
+
 	/// Block data sent in the response.
 	#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
 	pub struct BlockData<Header, Hash, Extrinsic> {
@@ -181,7 +215,7 @@ pub mod generic {
 		/// Block header if requested.
 		pub header: Option<Header>,
 		/// Block body if requested.
-		pub body: Option<Vec<Extrinsic>>,
+		pub body: Option<Body<Extrinsic>>,
 		/// Block receipt if requested.
 		pub receipt: Option<Vec<u8>>,
 		/// Block message queue if requested.

substrate/substrate/network/src/protocol.rs

@@ -262,7 +262,7 @@ impl<B: BlockT> Protocol<B> where
 			let block_data = message::generic::BlockData {
 				hash: hash,
 				header: if get_header { Some(header) } else { None },
-				body: if get_body { self.chain.body(&BlockId::Hash(hash)).unwrap_or(None) } else { None },
+				body: (if get_body { self.chain.body(&BlockId::Hash(hash)).unwrap_or(None) } else { None }).map(|body| message::Body::Extrinsics(body)),
 				receipt: None,
 				message_queue: None,
 				justification: if get_justification { self.chain.justification(&BlockId::Hash(hash)).unwrap_or(None) } else { None },

substrate/substrate/network/src/sync.rs

@@ -259,7 +259,7 @@ impl<B: BlockT> ChainSync<B> where
 						is_best,
 						header,
 						justification,
-						block.body
+						block.body.map(|b| b.to_extrinsics()),
 					);
 					match result {
 						Ok(ImportResult::AlreadyInChain) => {

substrate/substrate/primitives/src/storage.rs

@@ -22,10 +22,10 @@ use rstd::vec::Vec;
 
 /// Contract storage key.
 #[derive(PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug, Hash, PartialOrd, Ord))]
 pub struct StorageKey(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
 
 /// Contract storage entry data.
 #[derive(PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug, Hash, PartialOrd, Ord))]
 pub struct StorageData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);

substrate/substrate/rpc/src/chain/tests.rs

@@ -34,7 +34,7 @@ fn should_return_header() {
 		Ok(Some(ref x)) if x == &Header {
 			parent_hash: 0.into(),
 			number: 0,
-			state_root: "9c70014029b05f780858f654bfcf297ca708b3663d32bc81486193e84a2f2f3d".into(),
+			state_root: "987aa0851a133413b42c6d9aa3c91b1dddc2ad5337508ee8815116b11e44c64d".into(),
 			extrinsics_root: "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421".into(),
 			digest: Default::default(),
 		}
@@ -70,7 +70,7 @@ fn should_notify_about_latest_block() {
 	// assert notification send to transport
 	let (notification, next) = core.run(transport.into_future()).unwrap();
 	assert_eq!(notification, Some(
-		r#"{"jsonrpc":"2.0","method":"test","params":{"result":{"digest":{"logs":[]},"extrinsicsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","number":1,"parentHash":"0x45a44c50cae6ffcc413b65d6b4444a572fa4be2e5d1cd026cc113f9d8f9bc368","stateRoot":"0x987aa0851a133413b42c6d9aa3c91b1dddc2ad5337508ee8815116b11e44c64d"},"subscription":0}}"#.to_owned()
+		r#"{"jsonrpc":"2.0","method":"test","params":{"result":{"digest":{"logs":[]},"extrinsicsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","number":1,"parentHash":"0x27f04d7574733bb155bbf5a0399fcc99d3c4dbf15bf99862d261bced9444179a","stateRoot":"0x987aa0851a133413b42c6d9aa3c91b1dddc2ad5337508ee8815116b11e44c64d"},"subscription":0}}"#.to_owned()
 	));
 	// no more notifications on this channel
 	assert_eq!(core.run(next.into_future()).unwrap().0, None);

substrate/substrate/runtime/consensus/src/lib.rs

@@ -134,9 +134,9 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use codec::{Slicable, KeyedVec};
 		let auth_count = self.authorities.len() as u32;
 		let mut r: runtime_io::TestExternalities = self.authorities.into_iter().enumerate().map(|(i, v)|

substrate/substrate/runtime/council/src/lib.rs

@@ -583,9 +583,9 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use codec::Slicable;
 		use runtime_io::twox_128;
 
@@ -613,7 +613,7 @@ mod tests {
 	pub use super::*;
 	pub use runtime_io::with_externalities;
 	pub use substrate_primitives::H256;
-	use primitives::BuildExternalities;
+	use primitives::BuildStorage;
 	use primitives::traits::{HasPublicAux, Identity, BlakeTwo256};
 	use primitives::testing::{Digest, Header};
 
@@ -658,15 +658,15 @@ mod tests {
 	impl Trait for Test {}
 
 	pub fn new_test_ext(with_council: bool) -> runtime_io::TestExternalities {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
 		t.extend(consensus::GenesisConfig::<Test>{
 			code: vec![],
 			authorities: vec![],
-		}.build_externalities());
+		}.build_storage());
 		t.extend(session::GenesisConfig::<Test>{
 			session_length: 1,		//??? or 2?
 			validators: vec![10, 20],
-		}.build_externalities());
+		}.build_storage());
 		t.extend(staking::GenesisConfig::<Test>{
 			sessions_per_era: 1,
 			current_era: 0,
@@ -681,12 +681,12 @@ mod tests {
 			creation_fee: 0,
 			contract_fee: 0,
 			reclaim_rebate: 0,
-		}.build_externalities());
+		}.build_storage());
 		t.extend(democracy::GenesisConfig::<Test>{
 			launch_period: 1,
 			voting_period: 3,
 			minimum_deposit: 1,
-		}.build_externalities());
+		}.build_storage());
 		t.extend(GenesisConfig::<Test>{
 			candidacy_bond: 9,
 			voter_bond: 3,
@@ -704,7 +704,7 @@ mod tests {
 			term_duration: 5,
 			cooloff_period: 2,
 			voting_period: 1,
-		}.build_externalities());
+		}.build_storage());
 		t
 	}
 

substrate/substrate/runtime/democracy/src/lib.rs

@@ -331,9 +331,9 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use codec::Slicable;
 		use runtime_io::twox_128;
 
@@ -353,7 +353,7 @@ mod tests {
 	use super::*;
 	use runtime_io::with_externalities;
 	use substrate_primitives::H256;
-	use primitives::BuildExternalities;
+	use primitives::BuildStorage;
 	use primitives::traits::{HasPublicAux, Identity, BlakeTwo256};
 	use primitives::testing::{Digest, Header};
 
@@ -398,15 +398,15 @@ mod tests {
 	}
 
 	fn new_test_ext() -> runtime_io::TestExternalities {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
 		t.extend(consensus::GenesisConfig::<Test>{
 			code: vec![],
 			authorities: vec![],
-		}.build_externalities());
+		}.build_storage());
 		t.extend(session::GenesisConfig::<Test>{
 			session_length: 1,		//??? or 2?
 			validators: vec![10, 20],
-		}.build_externalities());
+		}.build_storage());
 		t.extend(staking::GenesisConfig::<Test>{
 			sessions_per_era: 1,
 			current_era: 0,
@@ -421,12 +421,12 @@ mod tests {
 			creation_fee: 0,
 			contract_fee: 0,
 			reclaim_rebate: 0,
-		}.build_externalities());
+		}.build_storage());
 		t.extend(GenesisConfig::<Test>{
 			launch_period: 1,
 			voting_period: 1,
 			minimum_deposit: 1,
-		}.build_externalities());
+		}.build_storage());
 		t
 	}
 

substrate/substrate/runtime/executive/src/lib.rs

@@ -216,7 +216,7 @@ mod tests {
 	use staking::Call;
 	use runtime_io::with_externalities;
 	use substrate_primitives::H256;
-	use primitives::BuildExternalities;
+	use primitives::BuildStorage;
 	use primitives::traits::{HasPublicAux, Identity, Header as HeaderT, BlakeTwo256, AuxLookup};
 	use primitives::testing::{Digest, Header, Block};
 
@@ -262,7 +262,7 @@ mod tests {
 
 	#[test]
 	fn staking_balance_transfer_dispatch_works() {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
 		t.extend(staking::GenesisConfig::<Test> {
 			sessions_per_era: 0,
 			current_era: 0,
@@ -277,7 +277,7 @@ mod tests {
 			creation_fee: 0,
 			contract_fee: 0,
 			reclaim_rebate: 0,
-		}.build_externalities());
+		}.build_storage());
 		let xt = primitives::testing::TestXt((1, 0, Call::transfer(2.into(), 69)));
 		with_externalities(&mut t, || {
 			Executive::initialise_block(&Header::new(1, H256::default(), H256::default(), [69u8; 32].into(), Digest::default()));
@@ -288,10 +288,10 @@ mod tests {
 	}
 
 	fn new_test_ext() -> runtime_io::TestExternalities {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
-		t.extend(consensus::GenesisConfig::<Test>::default().build_externalities());
-		t.extend(session::GenesisConfig::<Test>::default().build_externalities());
-		t.extend(staking::GenesisConfig::<Test>::default().build_externalities());
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
+		t.extend(consensus::GenesisConfig::<Test>::default().build_storage());
+		t.extend(session::GenesisConfig::<Test>::default().build_storage());
+		t.extend(staking::GenesisConfig::<Test>::default().build_storage());
 		t
 	}
 

substrate/substrate/runtime/primitives/src/lib.rs

@@ -52,12 +52,32 @@ pub mod bft;
 
 use traits::{Verify, Lazy};
 
+/// A set of key value pairs for storage.
 #[cfg(feature = "std")]
-pub type BuiltExternalities = HashMap<Vec<u8>, Vec<u8>>;
+pub type StorageMap = HashMap<Vec<u8>, Vec<u8>>;
+
+/// A simple function allowing StorageMap to be created.
+#[cfg(feature = "std")]
+pub type MakeStorage = Box<FnMut() -> StorageMap>;
+
+/// Complex storage builder stuff.
+#[cfg(feature = "std")]
+pub trait BuildStorage {
+	fn build_storage(self) -> StorageMap;
+}
 
 #[cfg(feature = "std")]
-pub trait BuildExternalities {
-	fn build_externalities(self) -> BuiltExternalities;
+impl BuildStorage for MakeStorage {
+	fn build_storage(mut self) -> StorageMap {
+		self()
+	}
+}
+
+#[cfg(feature = "std")]
+impl BuildStorage for StorageMap {
+	fn build_storage(self) -> StorageMap {
+		self
+	}
 }
 
 /// Ed25519 signature verify.
@@ -227,12 +247,12 @@ macro_rules! impl_outer_config {
 			)*
 		}
 		#[cfg(any(feature = "std", test))]
-		impl $crate::BuildExternalities for $main {
-			fn build_externalities(self) -> $crate::BuiltExternalities {
-				let mut s = $crate::BuiltExternalities::new();
+		impl $crate::BuildStorage for $main {
+			fn build_storage(self) -> $crate::StorageMap {
+				let mut s = $crate::StorageMap::new();
 				$(
 					if let Some(extra) = self.$snake {
-						s.extend(extra.build_externalities());
+						s.extend(extra.build_storage());
 					}
 				)*
 				s

substrate/substrate/runtime/session/src/lib.rs

@@ -185,9 +185,9 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use runtime_io::twox_128;
 		use codec::Slicable;
 		use primitives::traits::As;
@@ -204,7 +204,7 @@ mod tests {
 	use super::*;
 	use runtime_io::with_externalities;
 	use substrate_primitives::H256;
-	use primitives::BuildExternalities;
+	use primitives::BuildStorage;
 	use primitives::traits::{HasPublicAux, Identity, BlakeTwo256};
 	use primitives::testing::{Digest, Header};
 
@@ -235,15 +235,15 @@ mod tests {
 	type Session = Module<Test>;
 
 	fn new_test_ext() -> runtime_io::TestExternalities {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
 		t.extend(consensus::GenesisConfig::<Test>{
 			code: vec![],
 			authorities: vec![1, 2, 3],
-		}.build_externalities());
+		}.build_storage());
 		t.extend(GenesisConfig::<Test>{
 			session_length: 2,
 			validators: vec![1, 2, 3],
-		}.build_externalities());
+		}.build_storage());
 		t
 	}
 

substrate/substrate/runtime/staking/src/lib.rs

@@ -1031,8 +1031,8 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T> {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T> {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use runtime_io::twox_128;
 		use codec::Slicable;
 

substrate/substrate/runtime/staking/src/mock.rs

@@ -18,7 +18,7 @@
 
 #![cfg(test)]
 
-use primitives::BuildExternalities;
+use primitives::BuildStorage;
 use primitives::traits::{HasPublicAux, Identity};
 use primitives::testing::{Digest, Header};
 use substrate_primitives::H256;
@@ -54,7 +54,7 @@ impl Trait for Test {
 }
 
 pub fn new_test_ext(ext_deposit: u64, session_length: u64, sessions_per_era: u64, current_era: u64, monied: bool) -> runtime_io::TestExternalities {
-	let mut t = system::GenesisConfig::<Test>::default().build_externalities();
+	let mut t = system::GenesisConfig::<Test>::default().build_storage();
 	let balance_factor = if ext_deposit > 0 {
 		256
 	} else {
@@ -63,11 +63,11 @@ pub fn new_test_ext(ext_deposit: u64, session_length: u64, sessions_per_era: u64
 	t.extend(consensus::GenesisConfig::<Test>{
 		code: vec![],
 		authorities: vec![],
-	}.build_externalities());
+	}.build_storage());
 	t.extend(session::GenesisConfig::<Test>{
 		session_length,
 		validators: vec![10, 20],
-	}.build_externalities());
+	}.build_storage());
 	t.extend(GenesisConfig::<Test>{
 		sessions_per_era,
 		current_era,
@@ -82,7 +82,7 @@ pub fn new_test_ext(ext_deposit: u64, session_length: u64, sessions_per_era: u64
 		creation_fee: 0,
 		contract_fee: 0,
 		reclaim_rebate: 0,
-	}.build_externalities());
+	}.build_storage());
 	t
 }
 

substrate/substrate/runtime/system/src/lib.rs

@@ -203,9 +203,9 @@ impl<T: Trait> Default for GenesisConfig<T> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_io::TestExternalities {
+	fn build_storage(self) -> runtime_io::TestExternalities {
 		use runtime_io::twox_128;
 		use codec::Slicable;
 

substrate/substrate/runtime/timestamp/src/lib.rs

@@ -98,9 +98,9 @@ pub struct GenesisConfig<T: Trait> {
 }
 
 #[cfg(any(feature = "std", test))]
-impl<T: Trait> runtime_primitives::BuildExternalities for GenesisConfig<T>
+impl<T: Trait> runtime_primitives::BuildStorage for GenesisConfig<T>
 {
-	fn build_externalities(self) -> runtime_primitives::BuiltExternalities {
+	fn build_storage(self) -> runtime_primitives::StorageMap {
 		use runtime_io::twox_128;
 		use codec::Slicable;
 		map![
@@ -116,7 +116,7 @@ mod tests {
 	use runtime_io::with_externalities;
 	use runtime_support::storage::StorageValue;
 	use substrate_primitives::H256;
-	use runtime_primitives::BuildExternalities;
+	use runtime_primitives::BuildStorage;
 	use runtime_primitives::traits::{HasPublicAux, BlakeTwo256};
 	use runtime_primitives::testing::{Digest, Header};
 
@@ -142,8 +142,8 @@ mod tests {
 
 	#[test]
 	fn timestamp_works() {
-		let mut t = system::GenesisConfig::<Test>::default().build_externalities();
-		t.extend(GenesisConfig::<Test> { now: 42 }.build_externalities());
+		let mut t = system::GenesisConfig::<Test>::default().build_storage();
+		t.extend(GenesisConfig::<Test> { now: 42 }.build_storage());
 
 		with_externalities(&mut t, || {
 			assert_eq!(<Timestamp as Store>::Now::get(), 42);

substrate/substrate/test-client/src/client_ext.rs

@@ -18,6 +18,7 @@
 
 use client::{self, Client};
 use keyring::Keyring;
+use runtime_primitives::StorageMap;
 use runtime::genesismap::{GenesisConfig, additional_storage_with_genesis};
 use runtime;
 use bft;
@@ -37,7 +38,7 @@ pub trait TestClient {
 
 impl TestClient for Client<Backend, Executor, runtime::Block> {
 	fn new_for_tests() -> Self {
-		client::new_in_mem(NativeExecutor::new(), GenesisBuilder).unwrap()
+		client::new_in_mem(NativeExecutor::new(), genesis_storage()).unwrap()
 	}
 
 	fn justify_and_import(&self, origin: client::BlockOrigin, block: runtime::Block) -> client::error::Result<()> {
@@ -93,17 +94,9 @@ fn genesis_config() -> GenesisConfig {
 	], 1000)
 }
 
-struct GenesisBuilder;
-
-impl client::GenesisBuilder<runtime::Block> for GenesisBuilder {
-	fn build(self) -> (runtime::Header, Vec<(Vec<u8>, Vec<u8>)>) {
+fn genesis_storage() -> StorageMap {
 		let mut storage = genesis_config().genesis_map();
 		let block: runtime::Block = client::genesis::construct_genesis_block(&storage);
 		storage.extend(additional_storage_with_genesis(&block));
-
-		(
-			block.header,
-			storage.into_iter().collect()
-		)
-	}
+		storage
 }