Add validator set.

executor/src/error.rs

@@ -43,6 +43,12 @@ error_chain! {
 			display("Externalities error: {}", e),
 		}
 
+		/// Invalid index.
+		InvalidIndex {
+			description("index given was not in range"),
+			display("Invalid index provided"),
+		}
+
 		/// Invalid return type.
 		InvalidReturn {
 			description("u64 was not returned"),

executor/src/wasm_executor.rs

@@ -123,14 +123,33 @@ impl_function_executor!(this: FunctionExecutor<'e, E>,
 		} 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>
 );
 
-/// Dummy rust executor for contracts.
+/// Wasm rust executor for contracts.
 ///
-/// Instead of actually executing the provided code it just
-/// dispatches the calls to pre-defined hardcoded implementations in rust.
+/// Executes the provided code in a sandboxed wasm runtime.
 #[derive(Debug, Default)]
 pub struct WasmExecutor;
 
@@ -183,6 +202,7 @@ mod tests {
 	struct TestExternalities {
 		data: HashMap<Vec<u8>, Vec<u8>>,
 		code: Vec<u8>,
+		validators: Vec<Vec<u8>>,
 	}
 	impl Externalities for TestExternalities {
 		type Error = Error;
@@ -195,12 +215,34 @@ mod tests {
 			Ok(self.data.get(&key.to_vec()).map_or(&[] as &[u8], Vec::as_slice))
 		}
 
-		fn set_code(&mut self, _code: Vec<u8>) {
-			self.code = _code;
+		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;
+		}
+
+		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_storage(&mut self, _key: Vec<u8>, _value: Vec<u8>) {
-			self.data.insert(_key, _value);
+		fn set_validator_count(&mut self, count: usize) {
+			self.validators.resize(count, vec![]);
 		}
 	}
 

runtime/src/lib.rs

@@ -23,6 +23,10 @@ extern "C" {
 	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);
 }
 
 mod state {
@@ -39,7 +43,12 @@ mod state {
 	}
 
 	pub fn set_storage(key: &[u8], value: &[u8]) {
-		unsafe { super_set_storage(&key[0] as *const u8, key.len() as i32, &value[0] as *const u8, value.len() as i32); }
+		unsafe {
+			super_set_storage(
+				&key[0] as *const u8, key.len() as i32,
+				&value[0] as *const u8, value.len() as i32
+			);
+		}
 	}
 
 	pub fn code() -> Vec<u8> {
@@ -51,7 +60,9 @@ mod state {
 	}
 
 	pub fn set_code(new: &[u8]) {
-		unsafe { super_set_code(&new[0] as *const u8, new.len() as i32); }
+		unsafe {
+			super_set_code(&new[0] as *const u8, new.len() as i32);
+		}
 	}
 }
 
@@ -69,7 +80,9 @@ pub fn test(value: u64) -> u64 {
 /// Test passing of data.
 #[no_mangle]
 pub fn test_data_in(input_data: *mut u8, input_len: usize) {
-	let input = unsafe { Vec::from_raw_parts(input_data, input_len, input_len) };
+	let input = unsafe {
+		Vec::from_raw_parts(input_data, input_len, input_len)
+	};
 
 	state::set_storage(b"input", &input);
 	state::set_storage(b"code", &state::code());

state_machine/src/lib.rs

@@ -155,11 +155,23 @@ pub trait Externalities {
 	/// Read storage of current contract being called.
 	fn storage(&self, key: &[u8]) -> Result<&[u8], Self::Error>;
 
-	/// Set the new runtime.
+	/// Read the current validator set.
+	fn validator(&self, _index: usize) -> Result<&[u8], Self::Error> { Ok(&[]) }
+
+	/// How many validators are there?
+	fn validator_count(&self) -> usize { 0 }
+
+	/// Set the new runtime (effective from the next block).
 	fn set_code(&mut self, code: Vec<u8>);
 
-	/// Set storage of current contract being called.
+	/// Set storage of current contract being called (effective immediately).
 	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>);
+
+	/// Set a new validator set (effective from the next block).
+	fn set_validator(&mut self, _index: usize, _value: Vec<u8>) {}
+
+	/// Resize the validators array - extra validators will be empty vectors.
+	fn set_validator_count(&mut self, _count: usize) {}
 }
 
 /// Code execution engine.