Remove code and validators; use storage for everything.

executor/src/wasm_executor.rs

@@ -76,7 +76,13 @@ impl WritePrimitive<u32> for MemoryInstance {
 }
 
 impl_function_executor!(this: FunctionExecutor<'e, E>,
-	imported(n: u64) -> u64 => { println!("imported {:?}", n); n + 1 },
+	ext_print(utf8_data: *const u8, utf8_len: i32) => {
+		if let Ok(utf8) = this.memory.get(utf8_data, utf8_len as usize) {
+			if let Ok(message) = String::from_utf8(utf8) {
+				println!("Runtime: {}", message);
+			}
+		}
+	},
 	ext_memcpy(dest: *mut u8, src: *const u8, count: usize) -> *mut u8 => {
 		let _ = this.memory.copy_nonoverlapping(src as usize, dest as usize, count as usize);
 		println!("memcpy {} from {}, {} bytes", dest, src, count);
@@ -88,7 +94,7 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		dest
 	},
 	ext_memset(dest: *mut u8, val: i32, count: usize) -> *mut u8 => {
-//		let _ = this.memory.set(dest as usize, val as u8, count as usize);
+		let _ = this.memory.clear(dest as usize, val as u8, count as usize);
 		println!("memset {} with {}, {} bytes", dest, val, count);
 		dest
 	},
@@ -117,40 +123,6 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 
 		this.memory.write_primitive(written_out, written);
 		offset as u32
-	},
-	set_code(code_data: *const u8, code_len: i32) => {
-		if let Ok(code) = this.memory.get(code_data, code_len as usize) {
-			this.ext.set_code(code);
-		}
-	},
-	get_allocated_code(written_out: *mut i32) -> *mut u8 => {
-		let (offset, written) = if let Ok(code) = this.ext.code() {
-			let offset = this.heap.allocate(code.len() as u32) as u32;
-			let _ = this.memory.set(offset, &code);
-			(offset, code.len() as u32)
-		} else { (0, 0) };
-		this.memory.write_primitive(written_out, written);
-		offset as u32
-	},
-	get_validator_count() -> i32 => {
-		this.ext.validator_count() as i32
-	},
-	get_allocated_validator(index: i32, written_out: *mut i32) -> *mut u8 => {
-		let (offset, written) = if let Ok(v) = this.ext.validator(index as usize) {
-			let offset = this.heap.allocate(v.len() as u32) as u32;
-			let _ = this.memory.set(offset, &v);
-			(offset, v.len() as u32)
-		} else { (0, 0) };
-		this.memory.write_primitive(written_out, written);
-		offset as u32
-	},
-	set_validator_count(validator_count: i32) => {
-		this.ext.set_validator_count(validator_count as usize);
-	},
-	set_validator(index: i32, validator_data: *const u8, validator_len: i32) => {
-		if let Ok(validator) = this.memory.get(validator_data, validator_len as usize) {
-			this.ext.set_validator(index as usize, validator);
-		}
 	}
 	=> <'e, E: Externalities + 'e>
 );
@@ -167,21 +139,15 @@ impl CodeExecutor for WasmExecutor {
 	fn call<E: Externalities>(
 		&self,
 		ext: &mut E,
+		code: &[u8],
 		method: &str,
 		data: &CallData,
 	) -> Result<u64> {
-		// TODO: avoid copying code by requiring code to remain immutable through execution,
-		// splitting it off from potentially mutable externalities.
-		let code = match ext.code() {
-			Ok(e) => e.to_owned(),
-			Err(e) => Err(ErrorKind::Externalities(Box::new(e)))?,
-		};
-
 		// TODO: handle all expects as errors to be returned.
 
 		let program = ProgramInstance::new().expect("this really shouldn't be able to fail; qed");
 
-		let module = deserialize_buffer(code).expect("all modules compiled with rustc are valid wasm code; qed");
+		let module = deserialize_buffer(code.to_vec()).expect("all modules compiled with rustc are valid wasm code; qed");
 		let module = program.add_module_by_sigs("test", module, map!["env" => FunctionExecutor::<E>::SIGNATURES]).expect("runtime signatures always provided; qed");
 
 		let memory = module.memory(ItemIndex::Internal(0)).expect("all modules compiled with rustc include memory segments; qed");
@@ -208,56 +174,24 @@ mod tests {
 
 	#[derive(Debug, Default)]
 	struct TestExternalities {
-		data: HashMap<Vec<u8>, Vec<u8>>,
-		code: Vec<u8>,
-		validators: Vec<Vec<u8>>,
+		storage: HashMap<Vec<u8>, Vec<u8>>,
 	}
 	impl Externalities for TestExternalities {
 		type Error = Error;
 
-		fn code(&self) -> Result<&[u8]> {
-			Ok(self.code.as_slice())
-		}
-
 		fn storage(&self, key: &[u8]) -> Result<&[u8]> {
-			Ok(self.data.get(&key.to_vec()).map_or(&[] as &[u8], Vec::as_slice))
-		}
-
-		fn validator(&self, index: usize) -> Result<&[u8]> {
-			if index < self.validators.len() {
-				Ok(self.validators[index].as_slice())
-			} else {
-				Err(ErrorKind::InvalidIndex.into())
-			}
-		}
-
-		fn validator_count(&self) -> usize {
-			self.validators.len()
-		}
-
-		fn set_code(&mut self, code: Vec<u8>) {
-			self.code = code;
+			Ok(self.storage.get(&key.to_vec()).map_or(&[] as &[u8], Vec::as_slice))
 		}
 
 		fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
-			self.data.insert(key, value);
-		}
-
-		fn set_validator(&mut self, index: usize, value: Vec<u8>) {
-			if index < self.validators.len() {
-				self.validators[index] = value;
-			}
-		}
-
-		fn set_validator_count(&mut self, count: usize) {
-			self.validators.resize(count, vec![]);
+			self.storage.insert(key, value);
 		}
 	}
 
 	#[test]
 	fn should_pass_externalities_at_call() {
 		let mut ext = TestExternalities::default();
-		ext.code = b"The code".to_vec();
+		ext.set_storage(b"\0code".to_vec(), b"The code".to_vec());
 
 		let program = ProgramInstance::new().unwrap();
 
@@ -274,20 +208,20 @@ mod tests {
 			let offset = fec.heap.allocate(size);
 			memory.set(offset, data).unwrap();
 
-			module.execute_export("test_data_in",
+			assert!(module.execute_export("test_data_in",
 				program.params_with_external("env", &mut fec)
 					.add_argument(I32(offset as i32))
 					.add_argument(I32(size as i32))
-			).unwrap();
+			).is_ok());
 		}
 
 		let expected: HashMap<_, _> = map![
+			b"\0code".to_vec() => b"Hello world".to_vec(),
 			b"input".to_vec() => b"Hello world".to_vec(),
-			b"code".to_vec() => b"The code".to_vec()
+			b"code".to_vec() => b"The code".to_vec(),
+			b"\0validator_count".to_vec() => vec![1],
+			b"\0validator".to_vec() => b"Hello world".to_vec()
 		];
-		assert_eq!(expected, ext.data);
-
-		let expected = vec![ b"Hello world".to_vec() ];
-		assert_eq!(expected, ext.validators);
+		assert_eq!(expected, ext.storage);
 	}
 }

runtime/src/lib.rs

@@ -5,7 +5,6 @@
 #![feature(alloc)]
 
 extern crate alloc;
-use alloc::boxed::Box;
 use alloc::vec::Vec;
 
 extern crate pwasm_libc;
@@ -18,22 +17,14 @@ pub fn panic_fmt() -> ! {
 }
 
 extern "C" {
-	fn imported(n: u64) -> u64;
+	fn ext_print(utf8_data: *const u8, utf8_len: i32);
 	fn set_storage(key_data: *const u8, key_len: i32, value_data: *const u8, value_len: i32);
 	fn get_allocated_storage(key_data: *const u8, key_len: i32, written_out: *mut i32) -> *mut u8;
-	fn set_code(code_data: *const u8, code_len: i32);
-	fn get_allocated_code(written_out: *mut i32) -> *mut u8;
-	fn get_validator_count() -> i32;
-	fn get_allocated_validator(index: i32, written_out: *mut i32) -> *mut u8;
-	fn set_validator_count(validator_count: i32);
-	fn set_validator(index: i32, validator_data: *const u8, validator_len: i32);
 }
 
 pub mod state {
 	use alloc::vec::Vec;
-	use super::{get_allocated_storage, set_storage as super_set_storage, get_allocated_code,
-		set_code as super_set_code, set_validator as super_set_validator, get_allocated_validator,
-		get_validator_count, set_validator_count as super_set_validator_count};
+	use super::{get_allocated_storage, set_storage as super_set_storage};
 
 	pub fn storage(key: &[u8]) -> Vec<u8> {
 		let mut length: i32 = 0;
@@ -53,43 +44,37 @@ pub mod state {
 	}
 
 	pub fn code() -> Vec<u8> {
-		let mut length: i32 = 0;
-		unsafe {
-			let ptr = get_allocated_code(&mut length);
-			Vec::from_raw_parts(ptr, length as usize, length as usize)
-		}
+		storage(b"\0code")
 	}
 
 	pub fn set_code(new: &[u8]) {
-		unsafe {
-			super_set_code(&new[0] as *const u8, new.len() as i32);
+		set_storage(b"\0code", new)
+	}
+
+	pub fn value_vec(mut value: usize, initial: Vec<u8>) -> Vec<u8> {
+		let mut acc = initial;
+		while value > 0 {
+			acc.push(value as u8);
+			value /= 256;
 		}
+		acc
 	}
 
 	pub fn set_validator(index: usize, validator: &[u8]) {
-		unsafe {
-			super_set_validator(index as i32, &validator[0] as *const u8, validator.len() as i32);
-		}
+		set_storage(&value_vec(index, b"\0validator".to_vec()), validator);
 	}
 
 	pub fn validator(index: usize) -> Vec<u8> {
-		let mut length: i32 = 0;
-		unsafe {
-			let ptr = get_allocated_validator(index as i32, &mut length);
-			Vec::from_raw_parts(ptr, length as usize, length as usize)
-		}
+		storage(&value_vec(index, b"\0validator".to_vec()))
 	}
 
 	pub fn set_validator_count(count: usize) {
-		unsafe {
-			super_set_validator_count(count as i32);
-		}
+		(count..validator_count()).for_each(|i| set_validator(i, &[]));
+		set_storage(b"\0validator_count", &value_vec(count, Vec::new()));
 	}
 
 	pub fn validator_count() -> usize {
-		unsafe {
-			get_validator_count() as usize
-		}
+		storage(b"\0validator_count").into_iter().rev().fold(0, |acc, i| acc << 8 + (i as usize))
 	}
 
 	pub fn validators() -> Vec<Vec<u8>> {
@@ -102,15 +87,10 @@ pub mod state {
 	}
 }
 
-fn do_something(param: u64) -> u64 {
-	param * 2
-}
-
-/// Test some execution.
-#[no_mangle]
-pub fn test(value: u64) -> u64 {
-	let b = Box::new(unsafe { imported(value) });
-	do_something(*b)
+pub fn print(utf8: &[u8]) {
+	unsafe {
+		ext_print(&utf8[0] as *const u8, utf8.len() as i32);
+	}
 }
 
 /// Test passing of data.
@@ -120,18 +100,24 @@ pub fn test_data_in(input_data: *mut u8, input_len: usize) {
 		Vec::from_raw_parts(input_data, input_len, input_len)
 	};
 
+	print(b"set_storage");
 	state::set_storage(b"input", &input);
+
+	print(b"code");
 	state::set_storage(b"code", &state::code());
 
+	print(b"set_code");
 	state::set_code(&input);
-	let copy = state::storage(b"input");
 
-	// Do some stuff.
-	for b in &copy {
-		unsafe { imported(*b as u64); }
-	}
+	print(b"storage");
+	let copy = state::storage(b"input");
 
+	print(b"validators");
 	let mut v = state::validators();
 	v.push(copy);
+
+	print(b"set_validators");
 	state::set_validators(&v.iter().map(Vec::as_slice).collect::<Vec<_>>());
+
+	print(b"finished!");
 }

state_machine/src/backend.rs

@@ -17,16 +17,13 @@
 //! State machine backends. These manage the code and storage of contracts.
 
 use std::{error, fmt};
-use primitives::hash;
 use primitives::hash::H256;
 use triehash::sec_trie_root;
 
 use super::{Update, MemoryState};
 
 /// Output of a commit.
 pub struct Committed {
-	/// Root of the code tree after changes committed.
-	pub code_hash: H256,
 	/// Root of the storage tree after changes committed.
 	pub storage_tree_root: H256,
 }
@@ -85,11 +82,8 @@ impl Backend for InMemory {
 				.map(|(k, v)| (k.to_vec(), v.clone()))
 				.collect()
 			).0);
-		let code_hash = hash(&self.inner.code().unwrap_or_else(|| &[]));
-		// TODO: include validators list.
 
 		Committed {
-			code_hash,
 			storage_tree_root,
 		}
 	}

state_machine/src/ext.rs

@@ -25,8 +25,10 @@ use {Externalities, OverlayedChanges};
 #[derive(Debug, Copy, Clone)]
 pub enum Error<B, E> {
 	/// Failure to load state data from the backend.
+	#[allow(unused)]
 	Backend(B),
 	/// Failure to execute a function.
+	#[allow(unused)]
 	Executor(E),
 }
 
@@ -61,21 +63,13 @@ impl<'a, B: 'a> Externalities for Ext<'a, B>
 {
 	type Error = B::Error;
 
-	fn code(&self) -> Result<&[u8], Self::Error> {
-		Ok(self.overlay.code())
-	}
-
 	fn storage(&self, key: &[u8]) -> Result<&[u8], Self::Error> {
 		match self.overlay.storage(key) {
 			Some(x) => Ok(x),
 			None => self.backend.storage(key)
 		}
 	}
 
-	fn set_code(&mut self, code: Vec<u8>) {
-		self.overlay.set_code(code);
-	}
-
 	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
 		self.overlay.set_storage(key, value);
 	}