fix tests and review grumbles

substrate/Cargo.lock

@@ -1077,7 +1077,7 @@ dependencies = [
  "polkadot-runtime-codec 0.1.0",
  "polkadot-serializer 0.1.0",
  "pretty_assertions 0.4.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-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)",
  "twox-hash 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1332,6 +1332,11 @@ 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-serialize"
 version = "0.3.24"
@@ -1914,6 +1919,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum rust-crypto 0.2.36 (registry+https://github.com/rust-lang/crates.io-index)" = "f76d05d3993fd5f4af9434e8e436db163a12a9d40e1a58a726f27a01dfd12a2a"
 "checksum rustc-demangle 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "aee45432acc62f7b9a108cc054142dac51f979e69e71ddce7d6fc7adf29e817e"
 "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-serialize 0.3.24 (registry+https://github.com/rust-lang/crates.io-index)" = "dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"
 "checksum rustc_version 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b9743a7670d88d5d52950408ecdb7c71d8986251ab604d4689dd2ca25c9bca69"
 "checksum safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e27a8b19b835f7aea908818e871f5cc3a5a186550c30773be987e155e8163d8f"

substrate/client/src/genesis.rs

@@ -18,17 +18,16 @@
 
 use std::collections::HashMap;
 use primitives::block::{Block, Header};
-use primitives::H256;
 use triehash::trie_root;
 
 /// Create a genesis block, given the initial storage.
 pub fn construct_genesis_block(storage: &HashMap<Vec<u8>, Vec<u8>>) -> Block {
-	let state_root = H256(trie_root(storage.clone().into_iter()).0);
+	let state_root = trie_root(storage.clone().into_iter()).0.into();
 	let header = Header {
 		parent_hash: Default::default(),
 		number: 0,
 		state_root,
-		transaction_root: H256(trie_root(vec![].into_iter()).0),
+		transaction_root: trie_root(vec![].into_iter()).0.into(),
 		digest: Default::default(),
 	};
 	Block {
@@ -47,7 +46,7 @@ mod tests {
 	use state_machine::OverlayedChanges;
 	use state_machine::backend::InMemory;
 	use polkadot_executor::executor;
-	use primitives::{AccountId, Hash, H256};
+	use primitives::{AccountId, Hash};
 	use primitives::block::{Number as BlockNumber, Header, Digest};
 	use primitives::runtime_function::Function;
 	use primitives::transaction::{UncheckedTransaction, Transaction};
@@ -72,7 +71,7 @@ mod tests {
 			UncheckedTransaction { transaction, signature }
 		}).collect::<Vec<_>>();
 
-		let transaction_root = H256(ordered_trie_root(transactions.iter().map(Slicable::to_vec)).0);
+		let transaction_root = ordered_trie_root(transactions.iter().map(Slicable::to_vec)).0.into();
 
 		let mut header = Header {
 			parent_hash,
@@ -105,7 +104,7 @@ mod tests {
 		).unwrap();
 		header = Header::from_slice(&mut &ret_data[..]).unwrap();
 
-		(vec![].join(&Block { header, transactions }), H256(hash))
+		(vec![].join(&Block { header, transactions }), hash.into())
 	}
 
 	fn block1(genesis_hash: Hash, backend: &InMemory) -> (Vec<u8>, Hash) {
@@ -113,7 +112,7 @@ mod tests {
 			backend,
 			1,
 			genesis_hash,
-			H256(hex!("25e5b37074063ab75c889326246640729b40d0c86932edc527bc80db0e04fe5c")),
+			hex!("25e5b37074063ab75c889326246640729b40d0c86932edc527bc80db0e04fe5c").into(),
 			vec![Transaction {
 				signed: one(),
 				nonce: 0,
@@ -128,7 +127,7 @@ mod tests {
 			vec![one(), two()], 1000
 		).genesis_map();
 		let block = construct_genesis_block(&storage);
-		let genesis_hash = H256(block.header.blake2_256());
+		let genesis_hash = block.header.blake2_256().into();
 		storage.extend(additional_storage_with_genesis(&block).into_iter());
 
 		let mut overlay = OverlayedChanges::default();

substrate/executor/src/native_executor.rs

@@ -46,7 +46,7 @@ mod tests {
 	use native_runtime::support::{one, two, Hashable};
 	use native_runtime::runtime::staking::balance;
 	use state_machine::TestExternalities;
-	use primitives::{twox_128, Hash, H256};
+	use primitives::{twox_128, Hash};
 	use primitives::runtime_function::Function;
 	use primitives::block::{Header, Number as BlockNumber, Block, Digest};
 	use primitives::transaction::{Transaction, UncheckedTransaction};
@@ -167,7 +167,7 @@ mod tests {
 			UncheckedTransaction { transaction, signature }
 		}).collect::<Vec<_>>();
 
-		let transaction_root = H256(ordered_trie_root(transactions.iter().map(Slicable::to_vec)).0);
+		let transaction_root = ordered_trie_root(transactions.iter().map(Slicable::to_vec)).0.into();
 
 		let header = Header {
 			parent_hash,
@@ -178,14 +178,14 @@ mod tests {
 		};
 		let hash = header.blake2_256();
 
-		(Block { header, transactions }.to_vec(), H256(hash))
+		(Block { header, transactions }.to_vec(), hash.into())
 	}
 
 	fn block1() -> (Vec<u8>, Hash) {
 		construct_block(
 			1,
-			H256([69u8; 32]),
+			[69u8; 32].into(),
-			H256(hex!("2481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29db")),
+			hex!("2481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29db").into(),
 			vec![Transaction {
 				signed: one(),
 				nonce: 0,
@@ -198,7 +198,7 @@ mod tests {
 		construct_block(
 			2,
 			block1().1,
-			H256(hex!("2cdbbf9bd766c2286a5f4091c131fe161addd060ba6fc041b3419089f4601bda")),
+			hex!("e2ba57cfb94b870ea6670b012b49dc33cbb70e3aa8d36cf54dfa5e4e69cd0778").into(),
 			vec![
 				Transaction {
 					signed: two(),

substrate/primitives/Cargo.toml

@@ -6,7 +6,7 @@ authors = ["Parity Technologies <admin@parity.io>"]
 [dependencies]
 crunchy = "0.1"
 fixed-hash = { git = "https://github.com/rphmeier/primitives.git", branch = "compile-for-wasm", default_features = false }
-rustc-hex = { version = "1.0", optional = true }
+rustc-hex = { git = "https://github.com/rphmeier/rustc-hex.git", version = "2.0", default_features = false }
 serde = { version = "1.0", default_features = false }
 serde_derive = { version = "1.0", optional = true }
 uint = { git = "https://github.com/rphmeier/primitives.git", branch = "compile-for-wasm" }
@@ -26,7 +26,7 @@ std = [
 	"fixed-hash/std",
 	"polkadot-runtime-codec/std",
 	"serde/std",
-	"rustc-hex",
+	"rustc-hex/std",
 	"twox-hash",
 	"blake2-rfc",
 	"serde_derive",

substrate/primitives/src/lib.rs

@@ -21,7 +21,6 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(not(feature = "std"), feature(alloc))]
 
-#[cfg(feature = "std")]
 extern crate rustc_hex;
 
 extern crate serde;
@@ -77,6 +76,9 @@ pub mod transaction;
 pub mod uint;
 pub mod validator;
 
+#[cfg(test)]
+mod tests;
+
 #[cfg(feature = "std")]
 pub mod hashing;
 

substrate/primitives/src/runtime_function.rs

@@ -82,10 +82,12 @@ impl Slicable for Function {
 				Function::SessionSetKey(try_opt!(Slicable::from_slice(value))),
 			FunctionId::StakingStake => Function::StakingStake,
 			FunctionId::StakingUnstake => Function::StakingUnstake,
-			FunctionId::StakingTransfer => Function::StakingTransfer(
+			FunctionId::StakingTransfer => {
-				try_opt!(Slicable::from_slice(value)),
+				let to  = try_opt!(Slicable::from_slice(value));
-				try_opt!(Slicable::from_slice(value)),
+				let amount = try_opt!(Slicable::from_slice(value));
-			),
+
+				Function::StakingTransfer(to, amount)
+			}
 			FunctionId::GovernancePropose =>
 				Function::GovernancePropose(try_opt!(Slicable::from_slice(value))),
 			FunctionId::GovernanceApprove =>

substrate/primitives/src/tests.rs

@@ -0,0 +1,233 @@
+// 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/>.
+
+//! Tests.
+
+use codec::Slicable;
+
+use ::AccountId;
+use block::{Block, Header, Digest, Log};
+use runtime_function::Function;
+use transaction::{UncheckedTransaction, Transaction};
+
+#[test]
+fn serialise_transaction_works() {
+	let one: AccountId = [1u8; 32];
+	let two: AccountId = [2u8; 32];
+	let tx = Transaction {
+		signed: one.clone(),
+		nonce: 69,
+		function: Function::StakingTransfer(two, 69),
+	};
+
+	let serialised = tx.to_vec();
+	assert_eq!(serialised, vec![
+		1u8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		69, 0, 0, 0, 0, 0, 0, 0,
+		34,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			69, 0, 0, 0, 0, 0, 0, 0
+	]);
+}
+
+#[test]
+fn deserialise_transaction_works() {
+	let one: AccountId = [1u8; 32];
+	let two: AccountId = [2u8; 32];
+	let tx = Transaction {
+		signed: one.clone(),
+		nonce: 69,
+		function: Function::StakingTransfer(two, 69),
+	};
+
+	let data = [
+		1u8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+		69, 0, 0, 0, 0, 0, 0, 0,
+		34,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			69, 0, 0, 0, 0, 0, 0, 0
+	];
+	let deserialised = Transaction::from_slice(&mut &data[..]).unwrap();
+	assert_eq!(deserialised, tx);
+}
+
+#[test]
+fn serialise_header_works() {
+	let h = Header {
+		parent_hash: [4u8; 32].into(),
+		number: 42,
+		state_root: [5u8; 32].into(),
+		transaction_root: [6u8; 32].into(),
+		digest: Digest { logs: vec![ Log(b"one log".to_vec()), Log(b"another log".to_vec()) ], },
+	};
+	let serialised = h.to_vec();
+	assert_eq!(serialised, vec![
+		4u8, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+		42, 0, 0, 0, 0, 0, 0, 0,
+		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+		2, 0, 0, 0,
+			7, 0, 0, 0,
+				111, 110, 101, 32, 108, 111, 103,
+			11, 0, 0, 0,
+				97, 110, 111, 116, 104, 101, 114, 32, 108, 111, 103
+	]);
+}
+
+#[test]
+fn deserialise_header_works() {
+	let h = Header {
+		parent_hash: [4u8; 32].into(),
+		number: 42,
+		state_root: [5u8; 32].into(),
+		transaction_root: [6u8; 32].into(),
+		digest: Digest { logs: vec![ Log(b"one log".to_vec()), Log(b"another log".to_vec()) ], },
+	};
+	let data = [
+		4u8, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+		42, 0, 0, 0, 0, 0, 0, 0,
+		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+		2, 0, 0, 0,
+			7, 0, 0, 0,
+				111, 110, 101, 32, 108, 111, 103,
+			11, 0, 0, 0,
+				97, 110, 111, 116, 104, 101, 114, 32, 108, 111, 103
+	];
+	let deserialised = Header::from_slice(&mut &data[..]).unwrap();
+	assert_eq!(deserialised, h);
+}
+
+#[test]
+fn serialise_block_works() {
+	let one: AccountId = [1u8; 32];
+	let two: AccountId = [2u8; 32];
+	let tx1 = UncheckedTransaction {
+		transaction: Transaction {
+			signed: one.clone(),
+			nonce: 69,
+			function: Function::StakingTransfer(two, 69),
+		},
+		signature: [1u8; 64].into(),
+	};
+	let tx2 = UncheckedTransaction {
+		transaction: Transaction {
+			signed: two.clone(),
+			nonce: 42,
+			function: Function::StakingStake,
+		},
+		signature: [2u8; 64].into(),
+	};
+	let h = Header {
+		parent_hash: [4u8; 32].into(),
+		number: 42,
+		state_root: [5u8; 32].into(),
+		transaction_root: [6u8; 32].into(),
+		digest: Digest { logs: vec![ Log(b"one log".to_vec()), Log(b"another log".to_vec()) ], },
+	};
+	let b = Block {
+		header: h,
+		transactions: vec![tx1, tx2],
+	};
+	let serialised = b.to_vec();
+	assert_eq!(serialised, vec![
+		// header
+		4u8, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+		42, 0, 0, 0, 0, 0, 0, 0,
+		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+		2, 0, 0, 0,
+			7, 0, 0, 0,
+				111, 110, 101, 32, 108, 111, 103,
+			11, 0, 0, 0,
+				97, 110, 111, 116, 104, 101, 114, 32, 108, 111, 103,
+		// transactions
+		2, 0, 0, 0,
+			// tx1
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			69, 0, 0, 0, 0, 0, 0, 0,
+			34,
+				2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+				69, 0, 0, 0, 0, 0, 0, 0,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			// tx2
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			42, 0, 0, 0, 0, 0, 0, 0,
+			32,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+	]);
+}
+
+#[test]
+fn deserialise_block_works() {
+	let one: AccountId = [1u8; 32];
+	let two: AccountId = [2u8; 32];
+	let tx1 = UncheckedTransaction {
+		transaction: Transaction {
+			signed: one.clone(),
+			nonce: 69,
+			function: Function::StakingTransfer(two, 69),
+		},
+		signature: [1u8; 64].into(),
+	};
+	let tx2 = UncheckedTransaction {
+		transaction: Transaction {
+			signed: two.clone(),
+			nonce: 42,
+			function: Function::StakingStake,
+		},
+		signature: [2u8; 64].into(),
+	};
+	let h = Header {
+		parent_hash: [4u8; 32].into(),
+		number: 42,
+		state_root: [5u8; 32].into(),
+		transaction_root: [6u8; 32].into(),
+		digest: Digest { logs: vec![ Log(b"one log".to_vec()), Log(b"another log".to_vec()) ], },
+	};
+	let b = Block {
+		header: h,
+		transactions: vec![tx1, tx2],
+	};
+	let data = [
+		// header
+		4u8, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+		42, 0, 0, 0, 0, 0, 0, 0,
+		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+		2, 0, 0, 0,
+			7, 0, 0, 0,
+				111, 110, 101, 32, 108, 111, 103,
+			11, 0, 0, 0,
+				97, 110, 111, 116, 104, 101, 114, 32, 108, 111, 103,
+		// transactions
+		2, 0, 0, 0,
+			// tx1
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			69, 0, 0, 0, 0, 0, 0, 0,
+			34,
+				2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+				69, 0, 0, 0, 0, 0, 0, 0,
+			1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+			// tx2
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+			42, 0, 0, 0, 0, 0, 0, 0,
+			32,
+			2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+	];
+	let deserialised = Block::from_slice(&mut &data[..]).unwrap();
+	assert_eq!(deserialised, b);
+}

substrate/wasm-runtime/Cargo.lock

@@ -384,7 +384,7 @@ dependencies = [
  "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)",
  "polkadot-runtime-codec 0.1.0",
- "rustc-hex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "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)",
  "twox-hash 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -568,6 +568,11 @@ 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"
@@ -825,6 +830,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "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"

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

@@ -21,7 +21,7 @@ use runtime_std::prelude::*;
 use runtime_std::{mem, storage_root, enumerated_trie_root};
 use codec::{KeyedVec, Slicable};
 use support::{Hashable, storage, with_env};
-use primitives::{AccountId, Hash, H256, TxOrder};
+use primitives::{AccountId, Hash, TxOrder};
 use primitives::block::{Block, Header, Number as BlockNumber};
 use primitives::transaction::UncheckedTransaction;
 use primitives::runtime_function::Function;
@@ -78,7 +78,7 @@ pub mod internal {
 		// 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 = H256(enumerated_trie_root(&txs));
+		let txs_root = enumerated_trie_root(&txs).into();
 		debug_assert_hash(&header.transaction_root, &txs_root);
 		assert!(header.transaction_root == txs_root, "Transaction trie root must be valid.");
 
@@ -94,7 +94,7 @@ pub mod internal {
 		final_checks(&block);
 
 		// check storage root.
-		let storage_root = H256(storage_root());
+		let storage_root = storage_root().into();
 		debug_assert_hash(&header.state_root, &storage_root);
 		assert!(header.state_root == storage_root, "Storage root must match that calculated.");
 
@@ -125,7 +125,7 @@ pub mod internal {
 		staking::internal::check_new_era();
 		session::internal::check_rotate_session();
 
-		header.state_root = H256(storage_root());
+		header.state_root = storage_root().into();
 		with_env(|e| {
 			mem::swap(&mut header.digest, &mut e.digest);
 		});
@@ -218,7 +218,6 @@ mod tests {
 	use primitives::transaction::{UncheckedTransaction, Transaction};
 	use primitives::runtime_function::Function;
 	use primitives::block::{Header, Digest};
-	use primitives::hash::{H256, H512};
 	use runtime::staking;
 
 	#[test]
@@ -236,10 +235,8 @@ mod tests {
 				nonce: 0,
 				function: Function::StakingTransfer(two, 69),
 			},
-			signature: "b543b41e4b7a0270eddf57ed6c435df04bb63f71c79f6ae2530ab26c734bb4e8cd57b1c190c41d5791bcdea66a16c7339b1e883e5d0538ea2d9acea800d60a00".parse().unwrap(),
+			signature: "5f9832c5a4a39e2dd4a3a0c5b400e9836beb362cb8f7d845a8291a2ae6fe366612e080e4acd0b5a75c3d0b6ee69614a68fb63698c1e76bf1f2dcd8fa617ddf05".parse().unwrap(),
 		};
-		// tx: 2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000228000000d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000
-		// sig: b543b41e4b7a0270eddf57ed6c435df04bb63f71c79f6ae2530ab26c734bb4e8cd57b1c190c41d5791bcdea66a16c7339b1e883e5d0538ea2d9acea800d60a00
 
 		with_externalities(&mut t, || {
 			internal::execute_transaction(tx, Header::from_block_number(1));
@@ -280,10 +277,10 @@ mod tests {
 		let mut t = new_test_ext();
 
 		let h = Header {
-			parent_hash: H256([69u8; 32]),
+			parent_hash: [69u8; 32].into(),
 			number: 1,
-			state_root: H256(hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0")),
+			state_root: hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0").into(),
-			transaction_root: H256(hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")),
+			transaction_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
 			digest: Digest { logs: vec![], },
 		};
 
@@ -306,10 +303,10 @@ mod tests {
 		let mut t = new_test_ext();
 
 		let h = Header {
-			parent_hash: H256([69u8; 32]),
+			parent_hash: [69u8; 32].into(),
 			number: 1,
-			state_root: H256([0u8; 32]),
+			state_root: [0u8; 32].into(),
-			transaction_root: H256(hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")),
+			transaction_root: hex!("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421").into(),
 			digest: Digest { logs: vec![], },
 		};
 
@@ -332,10 +329,10 @@ mod tests {
 		let mut t = new_test_ext();
 
 		let h = Header {
-			parent_hash: H256([69u8; 32]),
+			parent_hash: [69u8; 32].into(),
 			number: 1,
-			state_root: H256(hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0")),
+			state_root: hex!("1ab2dbb7d4868a670b181327b0b6a58dc64b10cfb9876f737a5aa014b8da31e0").into(),
-			transaction_root: H256([0u8; 32]),
+			transaction_root: [0u8; 32].into(),
 			digest: Digest { logs: vec![], },
 		};