Introduce first groundwork for Wasm executor.

paritytech · rphmeier · Jan 8, 2018 · Dec 5, 2017 · Dec 6, 2017 · Dec 6, 2017
commit 4f5c5b6c176606b99640b7f64da7d23175bf31ed
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -18,3 +18,6 @@ members = [
 	"state_machine",
 	"validator",
 ]
+exclude = [
+	"runtime"
+]
diff --git a/client/src/lib.rs b/client/src/lib.rs
@@ -27,7 +27,7 @@ extern crate error_chain;
 pub mod error;
 
 use primitives::{block, Address, H256};
-use primitives::contract::{CallData, OutData, StorageData};
+use primitives::contract::{CallData, OutData, StorageKey, StorageData};
 use state_machine::backend::Backend;
 
 use self::error::ResultExt;
@@ -72,23 +72,22 @@ impl<B, E> Client<B, E> where
 	}
 
 	/// Return single storage entry of contract under given address in state in a block of given hash.
-	pub fn storage(&self, hash: &block::HeaderHash, address: &Address, key: &H256) -> error::Result<StorageData> {
+	pub fn storage(&self, hash: &block::HeaderHash, object: u64, key: &StorageKey) -> error::Result<StorageData> {
 		self.state_at(hash)?
-			.storage(address, key)
+			.storage(object, &key.0)
 			.map(|x| StorageData(x.to_vec()))
 			.chain_err(|| error::ErrorKind::Backend)
 	}
 
 	/// Execute a call to a contract on top of state in a block of given hash.
-	pub fn call(&self, hash: &block::HeaderHash, address: &Address, method: &str, call_data: &CallData) -> error::Result<OutData> {
+	pub fn call(&self, hash: &block::HeaderHash, method: &str, call_data: &CallData) -> error::Result<OutData> {
 		let state = self.state_at(hash)?;
 		let mut changes = state_machine::OverlayedChanges::default();
 
 		Ok(state_machine::execute(
 			&state,
 			&mut changes,
 			&self.executor,
-			address,
 			method,
 			call_data,
 		)?)

diff --git a/contracts/Cargo.toml b/contracts/Cargo.toml
@@ -10,6 +10,7 @@ polkadot-serializer = { path = "../serializer", version = "0.1" }
 polkadot-state-machine = { path = "../state_machine" , version = "0.1" }
 serde = "1.0"
 serde_derive = "1.0"
+parity-wasm = "0.17.0"
 
 [dev-dependencies]
 assert_matches = "1.1"
diff --git a/contracts/src/auth.rs b/contracts/src/auth.rs
@@ -18,7 +18,7 @@ use primitives::Address;
 use state_machine::StaticExternalities;
 
 use error::Result;
-use executor::RustExecutor;
+use rust_executor::RustExecutor;
 
 /// Data and some sort of Authentication Data
 type DataAndAuth = (Vec<u8>, Vec<u8>);

diff --git a/contracts/src/balances.rs b/contracts/src/balances.rs
@@ -19,7 +19,7 @@ use primitives::uint::U256;
 use state_machine::{Externalities, StaticExternalities};
 
 use error::Result;
-use executor::RustExecutor;
+use rust_executor::RustExecutor;
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Transfer {

diff --git a/contracts/src/error.rs b/contracts/src/error.rs
@@ -42,5 +42,11 @@ error_chain! {
 			description("externalities failure"),
 			display("Externalities error: {}", e),
 		}
+
+		/// Runtime failed.
+		Runtime {
+			description("runtime failure"),
+			display("Runtime error"),
+		}
 	}
 }
diff --git a/contracts/src/lib.rs b/contracts/src/lib.rs
@@ -17,31 +17,41 @@
 //! Temporary crate for contracts implementations.
 //!
 //! This will be replaced with WASM contracts stored on-chain.
+//! ** NOTE ***
+//! This is entirely deprecated with the idea of a single-module Wasm module for state transition.
+//! The dispatch table should be replaced with the specific functions needed:
+//! - execute_block(bytes)
+//! - init_block(PrevBlock?) -> InProgressBlock
+//! - add_transaction(InProgressBlock) -> InProgressBlock
+//! I leave it as is for now as it might be removed before this is ever done.
 
 #![warn(missing_docs)]
 
 extern crate polkadot_primitives as primitives;
 extern crate polkadot_serializer as serializer;
 extern crate polkadot_state_machine as state_machine;
 extern crate serde;
+extern crate parity_wasm;
 
 #[macro_use]
 extern crate error_chain;
-#[macro_use]
-extern crate serde_derive;
+//#[macro_use]
+//extern crate serde_derive;
 
 #[cfg(test)]
 #[macro_use]
 extern crate assert_matches;
-
+/*
 mod auth;
 mod balances;
 mod validator_set;
+pub mod rust_executor;
+*/
+mod wasm_executor;
 
 pub mod error;
-pub mod executor;
 
 /// Creates new RustExecutor for contracts.
-pub fn executor() -> executor::RustExecutor {
-	executor::RustExecutor::default()
+pub fn executor() -> wasm_executor::WasmExecutor {
+	wasm_executor::WasmExecutor::default()
 }
diff --git a/contracts/src/executor.rs → contracts/src/rust_executor.rs b/contracts/src/executor.rs → contracts/src/rust_executor.rs
@@ -36,43 +36,9 @@ pub struct RustExecutor {
 	validator_set: validator_set::Contract,
 }
 
-impl RustExecutor {
-	const AUTH: u8 = 1;
-	const BALANCES: u8 = 2;
-	const VALIDATOR_SET: u8 = 3;
-}
-
 impl CodeExecutor for RustExecutor {
 	type Error = Error;
 
-	fn call_static<E: StaticExternalities<Self>>(
-		&self,
-		ext: &E,
-		code: &[u8],
-		method: &str,
-		data: &CallData,
-	) -> Result<OutData> {
-		ensure!(code.len() == 1, ErrorKind::InvalidCode(code.to_vec()));
-
-		Ok(OutData(match code[0] {
-			Self::AUTH => match method {
-				"check_auth" => ser(&self.auth.check_auth(ext, de(&data.0)?)?),
-				m => bail!(ErrorKind::MethodNotFound(m.to_owned())),
-			},
-			Self::BALANCES => match method {
-				"balance_of" => ser(&self.balance.balance_of(ext, de(&data.0)?)?),
-				"next_nonce" => ser(&self.balance.next_nonce(ext, de(&data.0)?)?),
-				"transfer_preconditions" => ser(&self.balance.transfer_preconditions(ext, de(&data.0)?)?),
-				m => bail!(ErrorKind::MethodNotFound(m.to_owned())),
-			},
-			Self::VALIDATOR_SET => match method {
-				"validator_set" => ser(&self.validator_set.validator_set(ext, de(&data.0)?)?),
-				m => bail!(ErrorKind::MethodNotFound(m.to_owned())),
-			},
-			c => bail!(ErrorKind::InvalidCode(vec![c])),
-		}))
-	}
-
 	fn call<E: Externalities<Self>>(
 		&self,
 		ext: &mut E,
@@ -82,12 +48,14 @@ impl CodeExecutor for RustExecutor {
 	) -> Result<OutData> {
 		ensure!(code.len() == 1, ErrorKind::InvalidCode(code.to_vec()));
 
-		Ok(OutData(match code[0] {
-			Self::BALANCES=> match method {
-				"transfer" => ser(&self.balance.transfer(ext, de(&data.0)?)?),
-				m => bail!(ErrorKind::MethodNotFound(m.to_owned())),
-			},
-			c => bail!(ErrorKind::InvalidCode(vec![c])),
+		Ok(OutData(match method {
+			"check_auth" => ser(&self.auth.check_auth(ext, de(&data.0)?)?),
+			"balance_of" => ser(&self.balance.balance_of(ext, de(&data.0)?)?),
+			"next_nonce" => ser(&self.balance.next_nonce(ext, de(&data.0)?)?),
+			"transfer_preconditions" => ser(&self.balance.transfer_preconditions(ext, de(&data.0)?)?),
+			"validator_set" => ser(&self.validator_set.validator_set(ext, de(&data.0)?)?),
+			"transfer" => ser(&self.balance.transfer(ext, de(&data.0)?)?),
+			m => bail!(ErrorKind::MethodNotFound(m.to_owned())),
 		}))
 	}
 }
@@ -122,34 +90,14 @@ mod tests {
 		}
 	}
 
-	#[test]
-	fn should_fail_for_empty_or_unknown_code() {
-		// given
-		let mut ext = TestExternalities::default();
-		let executor = RustExecutor::default();
-
-		assert_matches!(
-			*executor.call(&mut ext, &[], "any", &CallData(vec![])).unwrap_err().kind(),
-			ErrorKind::InvalidCode(ref code) if code.is_empty()
-		);
-		assert_matches!(
-			*executor.call(&mut ext, &[1, 2], "any", &CallData(vec![])).unwrap_err().kind(),
-			ErrorKind::InvalidCode(ref code) if code.len() == 2
-		);
-		assert_matches!(
-			*executor.call(&mut ext, &[255,], "any", &CallData(vec![])).unwrap_err().kind(),
-			ErrorKind::InvalidCode(_)
-		);
-	}
-
 	#[test]
 	fn should_fail_on_invalid_method() {
 		// given
 		let mut ext = TestExternalities::default();
 		let executor = RustExecutor::default();
 
 		assert_matches!(
-			*executor.call(&mut ext, &[2], "any", &CallData(vec![])).unwrap_err().kind(),
+			*executor.call(&mut ext, "any", &CallData(vec![])).unwrap_err().kind(),
 			ErrorKind::MethodNotFound(ref method) if &*method == "any"
 		);
 	}

diff --git a/contracts/src/validator_set.rs b/contracts/src/validator_set.rs
@@ -18,7 +18,7 @@ use primitives::Address;
 use state_machine::StaticExternalities;
 
 use error::Result;
-use executor::RustExecutor;
+use rust_executor::RustExecutor;
 
 /// Harcoded validator set contract.
 #[derive(Debug, Default)]