Remove CallData/OutData.

substrate/Cargo.lock

@@ -1044,6 +1044,25 @@ dependencies = [
  "substrate-state-machine 0.1.0",
 ]
 
+[[package]]
+name = "polkadot-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)",
+ "pretty_assertions 0.4.1 (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)",
+ "substrate-codec 0.1.0",
+ "substrate-primitives 0.1.0",
+ "substrate-serializer 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 = "polkadot-rpc"
 version = "0.1.0"

substrate/Cargo.toml

@@ -21,6 +21,7 @@ members = [
 	"rpc-servers",
 	"rpc",
 	"codec",
+	"polkadot-primitives",
 	"runtime-std",
 	"serializer",
 	"state-machine",

substrate/client/src/genesis.rs

@@ -48,7 +48,6 @@ mod tests {
 	use substrate_executor::executor;
 	use primitives::relay::{AccountId, Hash, BlockNumber, Header, Digest, UncheckedTransaction,
 		Transaction, Function};
-	use primitives::contract::CallData;
 	use ed25519::Pair;
 
 	fn secret_for(who: &AccountId) -> Option<Pair> {
@@ -88,7 +87,7 @@ mod tests {
 				&mut overlay,
 				&executor(),
 				"execute_transaction",
-				&CallData(vec![].join(&header).join(tx))
+				&vec![].join(&header).join(tx)
 			).unwrap();
 			header = Header::from_slice(&mut &ret_data[..]).unwrap();
 		}
@@ -98,7 +97,7 @@ mod tests {
 			&mut overlay,
 			&executor(),
 			"finalise_block",
-			&CallData(vec![].join(&header))
+			&vec![].join(&header)
 		).unwrap();
 		header = Header::from_slice(&mut &ret_data[..]).unwrap();
 
@@ -137,7 +136,7 @@ mod tests {
 			&mut overlay,
 			&executor(),
 			"execute_block",
-			&CallData(b1data)
+			&b1data
 		).unwrap();
 	}
 }

substrate/client/src/lib.rs

@@ -48,7 +48,7 @@ pub use blockchain::Info as ChainInfo;
 pub use blockchain::BlockId;
 
 use primitives::relay::block;
-use primitives::contract::{CallData, StorageKey, StorageData};
+use primitives::contract::{StorageKey, StorageData};
 
 use blockchain::Backend as BlockchainBackend;
 use backend::BlockImportOperation;
@@ -156,7 +156,7 @@ impl<B, E> Client<B, E> where
 	/// Execute a call to a contract on top of state in a block of given hash.
 	///
 	/// No changes are made.
-	pub fn call(&self, hash: &block::HeaderHash, method: &str, call_data: &CallData) -> error::Result<CallResult> {
+	pub fn call(&self, hash: &block::HeaderHash, method: &str, call_data: &[u8]) -> error::Result<CallResult> {
 		let state = self.state_at(hash)?;
 		let mut changes = state_machine::OverlayedChanges::default();
 

substrate/executor/src/native_executor.rs

@@ -16,7 +16,6 @@
 
 use error::{Error, ErrorKind, Result};
 use native_runtime as runtime;
-use primitives::contract::CallData;
 use runtime_std;
 use state_machine::{Externalities, CodeExecutor};
 use wasm_executor::WasmExecutor;
@@ -37,16 +36,16 @@ impl CodeExecutor for NativeExecutor {
 		ext: &mut E,
 		code: &[u8],
 		method: &str,
-		data: &CallData,
+		data: &[u8],
 	) -> Result<Vec<u8>> {
 		// WARNING!!! This assumes that the runtime was built *before* the main project. Until we
 		// get a proper build script, this must be strictly adhered to or things will go wrong.
 		let native_equivalent = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm");
 		if code == &native_equivalent[..] {
 			runtime_std::with_externalities(ext, || match method {
-				"execute_block" => safe_call(|| runtime::execute_block(&data.0)),
-				"execute_transaction" => safe_call(|| runtime::execute_transaction(&data.0)),
-				"finalise_block" => safe_call(|| runtime::finalise_block(&data.0)),
+				"execute_block" => safe_call(|| runtime::execute_block(data)),
+				"execute_transaction" => safe_call(|| runtime::execute_transaction(data)),
+				"finalise_block" => safe_call(|| runtime::finalise_block(data)),
 				_ => Err(ErrorKind::MethodNotFound(method.to_owned()).into()),
 			})
 		} else {
@@ -90,7 +89,7 @@ mod tests {
 			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
 		], };
 
-		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_err());
 	}
 
@@ -101,7 +100,7 @@ mod tests {
 			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0]
 		], };
 
-		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_err());
 	}
 
@@ -114,7 +113,7 @@ mod tests {
 			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
 		], };
 
-		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {
@@ -132,7 +131,7 @@ mod tests {
 			twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
 		], };
 
-		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {
@@ -234,7 +233,7 @@ mod tests {
 	fn test_execution_works() {
 		let mut t = new_test_ext();
 		println!("Testing Wasm...");
-		let r = WasmExecutor.call(&mut t, COMPACT_CODE, "run_tests", &CallData(block2().0));
+		let r = WasmExecutor.call(&mut t, COMPACT_CODE, "run_tests", &block2().0);
 		assert!(r.is_ok());
 	}
 
@@ -242,14 +241,14 @@ mod tests {
 	fn full_native_block_import_works() {
 		let mut t = new_test_ext();
 
-		NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block1().0)).unwrap();
+		NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
 		runtime_std::with_externalities(&mut t, || {
 			assert_eq!(balance(&one()), 42);
 			assert_eq!(balance(&two()), 69);
 		});
 
-		NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block2().0)).unwrap();
+		NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
 		runtime_std::with_externalities(&mut t, || {
 			assert_eq!(balance(&one()), 32);
@@ -261,14 +260,14 @@ mod tests {
 	fn full_wasm_block_import_works() {
 		let mut t = new_test_ext();
 
-		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block1().0)).unwrap();
+		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap();
 
 		runtime_std::with_externalities(&mut t, || {
 			assert_eq!(balance(&one()), 42);
 			assert_eq!(balance(&two()), 69);
 		});
 
-		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block2().0)).unwrap();
+		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap();
 
 		runtime_std::with_externalities(&mut t, || {
 			assert_eq!(balance(&one()), 32);

substrate/executor/src/wasm_executor.rs

@@ -22,7 +22,6 @@ use std::collections::HashMap;
 use parity_wasm::{deserialize_buffer, ModuleInstanceInterface, ProgramInstance};
 use parity_wasm::interpreter::{ItemIndex, DummyUserError};
 use parity_wasm::RuntimeValue::{I32, I64};
-use primitives::contract::CallData;
 use state_machine::{Externalities, CodeExecutor};
 use error::{Error, ErrorKind, Result};
 use wasm_utils::{MemoryInstance, UserDefinedElements,
@@ -250,7 +249,7 @@ impl CodeExecutor for WasmExecutor {
 		ext: &mut E,
 		code: &[u8],
 		method: &str,
-		data: &CallData,
+		data: &[u8],
 	) -> Result<Vec<u8>> {
 		// TODO: handle all expects as errors to be returned.
 
@@ -262,9 +261,9 @@ impl CodeExecutor for WasmExecutor {
 		let memory = module.memory(ItemIndex::Internal(0)).expect("all modules compiled with rustc include memory segments; qed");
 		let mut fec = FunctionExecutor::new(&memory, ext);
 
-		let size = data.0.len() as u32;
+		let size = data.len() as u32;
 		let offset = fec.heap.allocate(size);
-		memory.set(offset, &data.0).expect("heap always gives a sensible offset to write");
+		memory.set(offset, &data).expect("heap always gives a sensible offset to write");
 
 		let returned = program
 				.params_with_external("env", &mut fec)
@@ -323,7 +322,7 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 
-		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_empty_return", &CallData(vec![])).unwrap();
+		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_empty_return", &[]).unwrap();
 		assert_eq!(output, vec![0u8; 0]);
 	}
 
@@ -332,10 +331,10 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 
-		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_panic", &CallData(vec![]));
+		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_panic", &[]);
 		assert!(output.is_err());
 
-		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_conditional_panic", &CallData(vec![2]));
+		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_conditional_panic", &[2]);
 		assert!(output.is_err());
 	}
 
@@ -345,7 +344,7 @@ mod tests {
 		ext.set_storage(b"foo".to_vec(), b"bar".to_vec());
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 
-		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_data_in", &CallData(b"Hello world".to_vec())).unwrap();
+		let output = WasmExecutor.call(&mut ext, &test_code[..], "test_data_in", b"Hello world").unwrap();
 
 		assert_eq!(output, b"all ok!".to_vec());
 
@@ -362,11 +361,11 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &CallData(b"".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &[]).unwrap(),
 			blake2_256(&b""[..]).to_vec()
 		);
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &CallData(b"Hello world!".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", b"Hello world!").unwrap(),
 			blake2_256(&b"Hello world!"[..]).to_vec()
 		);
 	}
@@ -376,11 +375,11 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &CallData(b"".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &[]).unwrap(),
 			FromHex::from_hex("99e9d85137db46ef4bbea33613baafd56f963c64b1f3685a4eb4abd67ff6203a").unwrap()
 		);
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &CallData(b"Hello world!".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", b"Hello world!").unwrap(),
 			FromHex::from_hex("b27dfd7f223f177f2a13647b533599af0c07f68bda23d96d059da2b451a35a74").unwrap()
 		);
 	}
@@ -390,11 +389,11 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &CallData(b"".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &[]).unwrap(),
 			FromHex::from_hex("99e9d85137db46ef4bbea33613baafd5").unwrap()
 		);
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &CallData(b"Hello world!".to_vec())).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", b"Hello world!").unwrap(),
 			FromHex::from_hex("b27dfd7f223f177f2a13647b533599af").unwrap()
 		);
 	}
@@ -409,7 +408,7 @@ mod tests {
 		calldata.extend_from_slice(key.public().as_ref());
 		calldata.extend_from_slice(sig.as_ref());
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_ed25519_verify", &CallData(calldata)).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_ed25519_verify", &calldata).unwrap(),
 			vec![0]
 		);
 	}
@@ -419,7 +418,7 @@ mod tests {
 		let mut ext = TestExternalities::default();
 		let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm");
 		assert_eq!(
-			WasmExecutor.call(&mut ext, &test_code[..], "test_enumerated_trie_root", &CallData(vec![])).unwrap(),
+			WasmExecutor.call(&mut ext, &test_code[..], "test_enumerated_trie_root", &[]).unwrap(),
 			ordered_trie_root(vec![b"zero".to_vec(), b"one".to_vec(), b"two".to_vec()]).0.to_vec()
 		);
 	}
@@ -432,7 +431,7 @@ mod tests {
 		], };
 
 		let foreign_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm");
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_err());
 	}
 
@@ -446,7 +445,7 @@ mod tests {
 		], };
 
 		let foreign_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm");
-		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx()));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {

substrate/polkadot-primitives/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "polkadot-primitives"
+version = "0.1.0"
+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 = { 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" }
+twox-hash = { version = "1.1.0", optional = true }
+byteorder = { version = "1.1", default_features = false }
+blake2-rfc = { version = "0.2.18", optional = true }
+substrate-codec = { path = "../codec", default_features = false }
+substrate-primitives = { path = "../primitives", default_features = false }
+
+[dev-dependencies]
+substrate-serializer = { path = "../serializer" }
+pretty_assertions = "0.4"
+
+[features]
+default = ["std"]
+std = [
+	"uint/std",
+	"fixed-hash/std",
+	"substrate-codec/std",
+	"serde/std",
+	"rustc-hex/std",
+	"twox-hash",
+	"blake2-rfc",
+	"serde_derive",
+	"byteorder/std"
+]

substrate/polkadot-primitives/src/lib.rs

@@ -0,0 +1,56 @@
+// 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/>.
+
+//! Shareable Polkadot types.
+
+#![warn(missing_docs)]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(not(feature = "std"), feature(alloc))]
+
+extern crate rustc_hex;
+
+extern crate serde;
+extern crate byteorder;
+
+#[cfg(feature = "std")]
+extern crate twox_hash;
+#[cfg(feature = "std")]
+extern crate blake2_rfc;
+
+#[macro_use]
+extern crate crunchy;
+#[macro_use]
+extern crate fixed_hash;
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate serde_derive;
+#[macro_use]
+extern crate uint as uint_crate;
+
+#[cfg(feature = "std")]
+extern crate core;
+extern crate substrate_codec as codec;
+extern crate substrate_primitives as primitives;
+#[cfg(test)]
+extern crate substrate_serializer;
+#[cfg(test)]
+#[macro_use]
+extern crate pretty_assertions;
+
+#[cfg(not(feature = "std"))]
+#[macro_use]
+extern crate alloc;

substrate/primitives/src/contract.rs

@@ -20,16 +20,6 @@
 use bytes;
 use bytes::Vec;
 
-/// Contract call data.
-#[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct CallData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
-
-/// Contract output data.
-#[derive(Debug, PartialEq, Eq)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct OutData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec<u8>);
-
 /// Contract storage key.
 #[derive(Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]

substrate/rpc/src/state/mod.rs

@@ -23,7 +23,7 @@ mod tests;
 
 use client::{self, Client};
 use primitives::relay::block;
-use primitives::contract::{CallData, StorageKey, StorageData};
+use primitives::contract::{StorageKey, StorageData};
 use state_machine;
 
 use self::error::Result;
@@ -37,7 +37,7 @@ build_rpc_trait! {
 
 		/// Call a contract.
 		#[rpc(name = "state_call")]
-		fn call(&self, String, CallData, block::HeaderHash) -> Result<Vec<u8>>;
+		fn call(&self, String, Vec<u8>, block::HeaderHash) -> Result<Vec<u8>>;
 	}
 }
 
@@ -50,7 +50,7 @@ impl<B, E> StateApi for Client<B, E> where
 		Ok(self.storage(&block, &key)?)
 	}
 
-	fn call(&self, method: String, data: CallData, block: block::HeaderHash) -> Result<Vec<u8>> {
+	fn call(&self, method: String, data: Vec<u8>, block: block::HeaderHash) -> Result<Vec<u8>> {
 		Ok(self.call(&block, &method, &data)?.return_data)
 	}
 }

substrate/rpc/src/state/tests.rs

@@ -39,7 +39,7 @@ fn should_call_contract() {
 	let genesis_hash = "af65e54217fb213853703d57b80fc5b2bb834bf923046294d7a49bff62f0a8b2".into();
 
 	assert_matches!(
-		StateApi::call(&client, "balanceOf".into(), CallData(vec![1,2,3]), genesis_hash),
+		StateApi::call(&client, "balanceOf".into(), vec![1,2,3], genesis_hash),
 		Err(Error(ErrorKind::Client(client::error::ErrorKind::Execution(_)), _))
 	)
 }

substrate/runtime-std/src/lib.rs

@@ -24,8 +24,6 @@
 #![cfg_attr(feature = "std", doc = "Polkadot runtime standard library as compiled when linked with Rust's standard library.")]
 #![cfg_attr(not(feature = "std"), doc = "Polkadot's runtime standard library as compiled without Rust's standard library.")]
 
-extern crate substrate_codec as codec;
-
 #[cfg(feature = "std")]
 include!("../with_std.rs");
 
@@ -39,47 +37,3 @@ pub mod prelude {
 	pub use ::vec::Vec;
 	pub use ::boxed::Box;
 }
-
-/// Type definitions and helpers for transactions.
-pub mod transaction {
-	pub use primitives::relay::{Transaction, UncheckedTransaction};
-	use primitives::relay::Signature;
-
-	#[cfg(feature = "std")]
-	use std::ops;
-
-	#[cfg(not(feature = "std"))]
-	use core::ops;
-
-	/// 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 ::ed25519_verify(&tx.signature.0, &msg, &tx.transaction.signed) {
-			Ok(CheckedTransaction(tx))
-		} else {
-			Err(tx)
-		}
-	}
-}

substrate/state-machine/src/lib.rs

@@ -34,8 +34,6 @@ extern crate byteorder;
 use std::collections::HashMap;
 use std::fmt;
 
-use primitives::contract::CallData;
-
 pub mod backend;
 mod ext;
 mod testing;
@@ -177,7 +175,7 @@ pub trait CodeExecutor: Sized + Send + Sync {
 		ext: &mut E,
 		code: &[u8],
 		method: &str,
-		data: &CallData,
+		data: &[u8],
 	) -> Result<Vec<u8>, Self::Error>;
 }
 
@@ -192,7 +190,7 @@ pub fn execute<B: backend::Backend, Exec: CodeExecutor>(
 	overlay: &mut OverlayedChanges,
 	exec: &Exec,
 	method: &str,
-	call_data: &CallData,
+	call_data: &[u8],
 ) -> Result<Vec<u8>, Box<Error>> {
 
 	let result = {

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

@@ -42,6 +42,50 @@ use runtime_std::prelude::*;
 use codec::Slicable;
 use primitives::relay::{Header, Block, UncheckedTransaction};
 
+/// Type definitions and helpers for transactions.
+pub mod transaction {
+	pub use primitives::relay::{Transaction, UncheckedTransaction};
+	use primitives::relay::Signature;
+
+	#[cfg(feature = "std")]
+	use std::ops;
+
+	#[cfg(not(feature = "std"))]
+	use core::ops;
+
+	/// 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_std::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> {

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

@@ -145,7 +145,7 @@ pub mod internal {
 }
 
 fn execute_transaction(utx: UncheckedTransaction) {
-	use runtime_std::transaction;
+	use ::transaction;
 
 	// Verify the signature is good.
 	let tx = match transaction::check(utx) {