WASM Runtime refactoring (#6596)

* refactoring to new pwasm-std

* pass reference

* remove ref

* missing underscores

ethcore/wasm/src/env.rs

@@ -102,6 +102,26 @@ pub const SIGNATURES: &'static [UserFunctionDescriptor] = &[
 		&[I32],
 		None,
 	),
+	Static(
+		"_sender",
+		&[I32],
+		None,
+	),
+	Static(
+		"_origin",
+		&[I32],
+		None,
+	),
+	Static(
+		"_address",
+		&[I32],
+		None,
+	),
+	Static(
+		"_value",
+		&[I32],
+		None,
+	),
 	Static(
 		"_timestamp",
 		&[],

ethcore/wasm/src/lib.rs

@@ -27,7 +27,6 @@ extern crate wasm_utils;
 
 mod runtime;
 mod ptr;
-mod call_args;
 mod result;
 #[cfg(test)]
 mod tests;
@@ -107,7 +106,12 @@ impl vm::Vm for WasmInterpreter {
 			env_memory,
 			DEFAULT_STACK_SPACE,
 			params.gas.low_u64(),
-			RuntimeContext::new(params.address, params.sender),
+			RuntimeContext {
+				address: params.address,
+				sender: params.sender,
+				origin: params.origin,
+				value: params.value.value(),
+			},
 			&self.program,
 		);
 
@@ -121,15 +125,8 @@ impl vm::Vm for WasmInterpreter {
 			})?
 		);
 
-		let d_ptr = runtime.write_descriptor(
-			call_args::CallArgs::new(
-				params.address,
-				params.sender,
-				params.origin,
-				params.value.value(),
-				params.data.unwrap_or(Vec::with_capacity(0)),
-			)
-		).map_err(|e| Error(e))?;
+		let d_ptr = runtime.write_descriptor(&params.data.unwrap_or_default())
+			.map_err(Error)?;
 
 		{
 			let execution_params = runtime.execution_params()

ethcore/wasm/src/runtime.rs

@@ -28,7 +28,6 @@ use util::Address;
 
 use vm::CallType;
 use super::ptr::{WasmPtr, Error as PtrError};
-use super::call_args::CallArgs;
 
 /// User trap in native code
 #[derive(Debug, Clone, PartialEq)]
@@ -97,17 +96,10 @@ impl From<PtrError> for UserTrap {
 }
 
 pub struct RuntimeContext {
-	address: Address,
-	sender: Address,
-}
-
-impl RuntimeContext {
-	pub fn new(address: Address, sender: Address) -> Self {
-		RuntimeContext {
-			address: address,
-			sender: sender,
-		}
-	}
+	pub address: Address,
+	pub sender: Address,
+	pub origin: Address,
+	pub value: U256,
 }
 
 /// Runtime enviroment data for wasm contract execution
@@ -442,10 +434,10 @@ impl<'a, 'b> Runtime<'a, 'b> {
 	}
 
 	/// Write call descriptor to wasm memory
-	pub fn write_descriptor(&mut self, call_args: CallArgs) -> Result<WasmPtr, InterpreterError> {
+	pub fn write_descriptor(&mut self, input: &[u8]) -> Result<WasmPtr, InterpreterError> {
 		let d_ptr = self.alloc(16)?;
 
-		let args_len = call_args.len();
+		let args_len = input.len() as u32;
 		let args_ptr = self.alloc(args_len)?;
 
 		// write call descriptor
@@ -457,11 +449,7 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		self.memory.set(d_ptr, &d_buf)?;
 
 		// write call args to memory
-		self.memory.set(args_ptr, &call_args.address)?;
-		self.memory.set(args_ptr+20, &call_args.sender)?;
-		self.memory.set(args_ptr+40, &call_args.origin)?;
-		self.memory.set(args_ptr+60, &call_args.value)?;
-		self.memory.set(args_ptr+92, &call_args.data)?;
+		self.memory.set(args_ptr, input)?;
 
 		Ok(d_ptr.into())
 	}
@@ -559,6 +547,39 @@ impl<'a, 'b> Runtime<'a, 'b> {
 		Ok(None)
 	}
 
+	fn sender(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		self.memory.set(return_ptr, &*self.context.sender)?;
+		Ok(None)
+	}
+
+	fn address(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		self.memory.set(return_ptr, &*self.context.address)?;
+		Ok(None)
+	}
+
+	fn origin(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		self.memory.set(return_ptr, &*self.context.origin)?;
+		Ok(None)
+	}
+
+	fn value(&mut self, context: InterpreterCallerContext)
+		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
+	{
+		let return_ptr = context.value_stack.pop_as::<i32>()? as u32;
+		let value: H256 = self.context.value.clone().into();
+		self.memory.set(return_ptr, &*value)?;
+		Ok(None)
+	}
+
 	fn timestamp(&mut self, _context: InterpreterCallerContext)
 		-> Result<Option<interpreter::RuntimeValue>, InterpreterError>
 	{
@@ -691,6 +712,18 @@ impl<'a, 'b> interpreter::UserFunctionExecutor<UserTrap> for Runtime<'a, 'b> {
 			"_gaslimit" => {
 				self.ext_gas_limit(context)
 			},
+			"_sender" => {
+				self.sender(context)
+			},
+			"_address" => {
+				self.address(context)
+			},
+			"_origin" => {
+				self.origin(context)
+			},
+			"_value" => {
+				self.value(context)
+			},
 			_ => {
 				trace!(target: "wasm", "Trapped due to unhandled function: '{}'", name);
 				Ok(self.unknown_trap(context)?)