initial merge

substrate/executor/src/lib.rs

@@ -40,6 +40,11 @@ extern crate byteorder;
 extern crate rustc_hex;
 extern crate native_runtime;
 extern crate triehash;
+#[macro_use] extern crate log;
+
+#[cfg(test)]
+#[macro_use]
+extern crate hex_literal;
 
 #[macro_use]
 extern crate error_chain;

substrate/executor/src/native_executor.rs

@@ -29,6 +29,7 @@ impl CodeExecutor for NativeExecutor {
 			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)),
 				_ => Err(ErrorKind::MethodNotFound(method.to_owned()).into()),
 			})
 		} else {
@@ -41,15 +42,28 @@ impl CodeExecutor for NativeExecutor {
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use codec::KeyedVec;
-	use native_runtime::support::{one, two, StaticHexInto};
+	use codec::{KeyedVec, Slicable};
+	use native_runtime::support::{one, two, Hashable};
+	use runtime_std::TestExternalities;
+	use native_runtime::support::{one, two, Hashable};
 	use native_runtime::runtime::staking::balance;
 	use state_machine::TestExternalities;
 	use primitives::twox_128;
 
 	const BLOATY_CODE: &[u8] = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm");
 	const COMPACT_CODE: &[u8] = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm");
-	fn tx() -> Vec<u8> { "2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee000000000000000002d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000b543b41e4b7a0270eddf57ed6c435df04bb63f71c79f6ae2530ab26c734bb4e8cd57b1c190c41d5791bcdea66a16c7339b1e883e5d0538ea2d9acea800d60a00".convert() }
+
+	fn tx() -> UncheckedTransaction {
+		let transaction = Transaction {
+			signed: one(),
+			nonce: 0,
+			function: Function::StakingTransfer(two(), 69),
+		};
+		let signature = secret_for(&transaction.signed).unwrap()
+			.sign(&transaction.to_vec())
+			.inner();
+		UncheckedTransaction { transaction, signature }
+	}
 
 	#[test]
 	fn panic_execution_with_foreign_code_gives_error() {
@@ -58,7 +72,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(tx()));
+		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_err());
 	}
 
@@ -69,7 +83,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(tx()));
+		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_err());
 	}
 
@@ -82,7 +96,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(tx()));
+		let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {
@@ -100,7 +114,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(tx()));
+		let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {
@@ -108,4 +122,143 @@ mod tests {
 			assert_eq!(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]
+		], }
+	}
+
+	use primitives::ed25519::Pair;
+	fn secret_for(who: &AccountID) -> Option<Pair> {
+		match who {
+			x if *x == one() => Some(Pair::from_seed(b"12345678901234567890123456789012")),
+			x if *x == two() => Some("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60".into()),
+			_ => None,
+		}
+	}
+
+	fn construct_block(number: BlockNumber, parent_hash: Hash, state_root: Hash, txs: Vec<Transaction>) -> (Vec<u8>, Hash) {
+		use triehash::ordered_trie_root;
+
+		let transactions = txs.into_iter().map(|transaction| {
+			let signature = secret_for(&transaction.signed).unwrap()
+				.sign(&transaction.to_vec())
+				.inner();
+			UncheckedTransaction { transaction, signature }
+		}).collect::<Vec<_>>();
+
+		let transaction_root = ordered_trie_root(transactions.iter().map(Slicable::to_vec)).0;
+
+		let header = Header {
+			parent_hash,
+			number,
+			state_root,
+			transaction_root,
+			digest: Digest { logs: vec![], },
+		};
+		let hash = header.blake2_256();
+
+		(Block { header, transactions }.to_vec(), hash)
+	}
+
+	fn block1() -> (Vec<u8>, Hash) {
+		construct_block(
+			1,
+			[69u8; 32],
+			hex!("2481853da20b9f4322f34650fea5f240dcbfb266d02db94bfa0153c31f4a29db"),
+			vec![Transaction {
+				signed: one(),
+				nonce: 0,
+				function: Function::StakingTransfer,
+				input_data: vec![].join(&two()).join(&69u64),
+			}]
+		)
+	}
+
+	fn block2() -> (Vec<u8>, Hash) {
+		construct_block(
+			2,
+			block1().1,
+			hex!("2e69e4405a13981224078ad5355c68401bf56d0fe3f14a3536734666e6a8a047"),
+			vec![
+				Transaction {
+					signed: two(),
+					nonce: 0,
+					function: Function::StakingTransfer,
+					input_data: vec![].join(&one()).join(&5u64),
+				},
+				Transaction {
+					signed: one(),
+					nonce: 1,
+					function: Function::StakingTransfer,
+					input_data: vec![].join(&two()).join(&15u64),
+				}
+			]
+		)
+	}
+
+	#[test]
+	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));
+		assert!(r.is_ok());
+	}
+
+	#[test]
+	fn full_native_block_import_works() {
+		let mut t = new_test_ext();
+
+		NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(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();
+
+		runtime_std::with_externalities(&mut t, || {
+			assert_eq!(balance(&one()), 32);
+			assert_eq!(balance(&two()), 79);
+		});
+	}
+
+	#[test]
+	fn full_wasm_block_import_works() {
+		let mut t = new_test_ext();
+
+		WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(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();
+
+		runtime_std::with_externalities(&mut t, || {
+			assert_eq!(balance(&one()), 32);
+			assert_eq!(balance(&two()), 79);
+		});
+	}
 }

substrate/executor/src/wasm_executor.rs

@@ -38,7 +38,7 @@ struct Heap {
 impl Heap {
 	fn new() -> Self {
 		Heap {
-			end: 1024,
+			end: 32768,
 		}
 	}
 	fn allocate(&mut self, size: u32) -> u32 {
@@ -94,17 +94,17 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 	ext_print_utf8(utf8_data: *const u8, utf8_len: u32) => {
 		if let Ok(utf8) = this.memory.get(utf8_data, utf8_len as usize) {
 			if let Ok(message) = String::from_utf8(utf8) {
-				println!("Runtime: {}", message);
+				info!(target: "runtime", "{}", message);
 			}
 		}
 	},
 	ext_print_hex(data: *const u8, len: u32) => {
 		if let Ok(hex) = this.memory.get(data, len as usize) {
-			println!("Runtime: {}", HexDisplay::from(&hex));
+			info!(target: "runtime", "{}", HexDisplay::from(&hex));
 		}
 	},
 	ext_print_num(number: u64) => {
-		println!("Runtime: {}", number);
+		info!(target: "runtime", "{}", number);
 	},
 	ext_memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 => {
 		let sl1 = this.memory.get(s1, n as usize).map_err(|_| DummyUserError)?;
@@ -118,34 +118,35 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 	ext_memcpy(dest: *mut u8, src: *const u8, count: usize) -> *mut u8 => {
 		this.memory.copy_nonoverlapping(src as usize, dest as usize, count as usize)
 			.map_err(|_| DummyUserError)?;
-		println!("memcpy {} from {}, {} bytes", dest, src, count);
+		trace!(target: "runtime-std", "memcpy {} from {}, {} bytes", dest, src, count);
 		dest
 	},
 	ext_memmove(dest: *mut u8, src: *const u8, count: usize) -> *mut u8 => {
 		this.memory.copy(src as usize, dest as usize, count as usize)
 			.map_err(|_| DummyUserError)?;
-		println!("memmove {} from {}, {} bytes", dest, src, count);
+		trace!(target: "runtime-std", "memmove {} from {}, {} bytes", dest, src, count);
 		dest
 	},
 	ext_memset(dest: *mut u8, val: u32, count: usize) -> *mut u8 => {
 		this.memory.clear(dest as usize, val as u8, count as usize)
 			.map_err(|_| DummyUserError)?;
-		println!("memset {} with {}, {} bytes", dest, val, count);
+		trace!(target: "runtime-std", "memset {} with {}, {} bytes", dest, val, count);
 		dest
 	},
 	ext_malloc(size: usize) -> *mut u8 => {
 		let r = this.heap.allocate(size);
-		println!("malloc {} bytes at {}", size, r);
+		trace!(target: "runtime-std", "malloc {} bytes at {}", size, r);
 		r
 	},
 	ext_free(addr: *mut u8) => {
 		this.heap.deallocate(addr);
-		println!("free {}", addr)
+		trace!(target: "runtime-std", "free {}", addr)
 	},
 	ext_set_storage(key_data: *const u8, key_len: u32, value_data: *const u8, value_len: u32) => {
-		if let (Ok(key), Ok(value)) = (this.memory.get(key_data, key_len as usize), this.memory.get(value_data, value_len as usize)) {
-			this.ext.set_storage(key, value);
-		}
+		let key = this.memory.get(key_data, key_len as usize).map_err(|_| DummyUserError)?;
+		let value = this.memory.get(value_data, value_len as usize).map_err(|_| DummyUserError)?;
+		info!(target: "runtime", "Setting storage: {} -> {}", HexDisplay::from(&key), HexDisplay::from(&value));
+		this.ext.set_storage(key, value);
 	},
 	ext_get_allocated_storage(key_data: *const u8, key_len: u32, written_out: *mut u32) -> *mut u8 => {
 		let key = this.memory.get(key_data, key_len as usize).map_err(|_| DummyUserError)?;
@@ -160,6 +161,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 	ext_get_storage_into(key_data: *const u8, key_len: u32, value_data: *mut u8, value_len: u32, value_offset: u32) -> u32 => {
 		let key = this.memory.get(key_data, key_len as usize).map_err(|_| DummyUserError)?;
 		let value = this.ext.storage(&key).map_err(|_| DummyUserError)?;
+		info!(target: "runtime", "Getting storage: {} ( -> {})", HexDisplay::from(&key), HexDisplay::from(&value));
 		let value = &value[value_offset as usize..];
 		let written = ::std::cmp::min(value_len as usize, value.len());
 		this.memory.set(value_data, &value[..written]).map_err(|_| DummyUserError)?;
@@ -169,7 +171,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		let r = this.ext.storage_root();
 		this.memory.set(result, &r[..]).map_err(|_| DummyUserError)?;
 	},
-	ext_enumerated_trie_root(values_data: *const u8, _values_len: u32, lens_data: *const u32, lens_len: u32, result: *mut u8) => {
+	ext_enumerated_trie_root(values_data: *const u8, lens_data: *const u32, lens_len: u32, result: *mut u8) => {
 		let values = (0..lens_len)
 			.map(|i| this.memory.read_primitive(lens_data + i * 4))
 			.collect::<::std::result::Result<Vec<u32>, DummyUserError>>()?
@@ -188,9 +190,17 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 	},
 	ext_twox_128(data: *const u8, len: u32, out: *mut u8) => {
 		let result = if len == 0 {
+			info!(target: "runtime", "XXhash: ''");
 			twox_128(&[0u8; 0])
 		} else {
-			twox_128(&this.memory.get(data, len as usize).map_err(|_| DummyUserError)?)
+			let key = this.memory.get(data, len as usize).map_err(|_| DummyUserError)?;
+			let hashed_key = twox_128(&key);
+			if let Ok(skey) = ::std::str::from_utf8(&key) {
+				info!(target: "runtime", "XXhash: {} -> {}", skey, HexDisplay::from(&hashed_key));
+			} else {
+				info!(target: "runtime", "XXhash: {} -> {}", HexDisplay::from(&key), HexDisplay::from(&hashed_key));
+			}
+			hashed_key
 		};
 		this.memory.set(out, &result).map_err(|_| DummyUserError)?;
 	},
@@ -280,14 +290,38 @@ mod tests {
 
 	use super::*;
 	use rustc_hex::FromHex;
-	use primitives::{blake2_256, twox_128};
-	use runtime_std;
+	use primitives::{AccountId, blake2_256, twox_128};
+	use primitives::block::Header;
+	use primitives::transaction::{Transaction, UncheckedTransaction};
 	use codec::KeyedVec;
 	use state_machine::TestExternalities;
-	use native_runtime::support::{one, two, StaticHexInto};
+	use runtime_std;
+	use native_runtime::support::{one, two};
 	use native_runtime::runtime::staking::balance;
+	use ed25519::Pair;
 
-	fn tx() -> Vec<u8> { "2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee000000000000000002d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000b543b41e4b7a0270eddf57ed6c435df04bb63f71c79f6ae2530ab26c734bb4e8cd57b1c190c41d5791bcdea66a16c7339b1e883e5d0538ea2d9acea800d60a00".convert() }
+	fn secret_for(who: &AccountId) -> Option<Pair> {
+		match who {
+			x if *x == one() => Some(Pair::from_seed(b"12345678901234567890123456789012")),
+			x if *x == two() => Some("9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60".into()),
+			_ => None,
+		}
+	}
+
+	fn tx() -> UncheckedTransaction {
+		use native_runtime::codec::Slicable;
+
+		let transaction = Transaction {
+			signed: one(),
+			nonce: 0,
+			function: Function::StakingTransfer(two(), 69),
+		};
+		let signature = secret_for(&transaction.signed).unwrap()
+			.sign(&transaction.to_vec())
+			.inner();
+
+		UncheckedTransaction { transaction, signature }
+	}
 
 	#[test]
 	fn returning_should_work() {
@@ -403,7 +437,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(tx()));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_err());
 	}
 
@@ -417,7 +451,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(tx()));
+		let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx())));
 		assert!(r.is_ok());
 
 		runtime_std::with_externalities(&mut t, || {