Changing delegatecall logic

src/evm/ext.rs

@@ -55,19 +55,9 @@ pub trait Ext {
 	/// and true if subcall was successfull.
 	fn call(&mut self, 
 			gas: &U256, 
-			address: &Address, 
-			value: &U256, 
-			data: &[u8], 
-			code_address: &Address, 
-			output: &mut [u8]) -> MessageCallResult;
-
-	/// Delegate Message call.
-	/// 
-	/// Returns Err, if we run out of gas.
-	/// Otherwise returns call_result which contains gas left 
-	/// and true if subcall was successfull.
-	fn delegatecall(&mut self, 
-			gas: &U256, 
+			sender_address: &Address, 
+			receive_address: &Address, 
+			value: Option<&U256>,
 			data: &[u8], 
 			code_address: &Address, 
 			output: &mut [u8]) -> MessageCallResult;

src/evm/interpreter.rs

@@ -587,7 +587,7 @@ impl Interpreter {
 					// and we don't want to copy
 					let input = unsafe { ::std::mem::transmute(mem.read_slice(in_off, in_size)) };
 					let output = mem.writeable_slice(out_off, out_size);
-					ext.delegatecall(&call_gas, input, &code_address, output)
+					ext.call(&call_gas, &params.sender, &params.address, None, input, &code_address, output)
 				};
 
 				return match call_result {
@@ -609,11 +609,6 @@ impl Interpreter {
 
 				let value = stack.pop_back();
 
-				let address = match instruction == instructions::CALL {
-					true => &code_address,
-					false => &params.address
-				};
-
 				let in_off = stack.pop_back();
 				let in_size = stack.pop_back();
 				let out_off = stack.pop_back();
@@ -624,6 +619,11 @@ impl Interpreter {
 					false => U256::zero()
 				};
 
+				let (sender_address, receive_address) = match instruction == instructions::CALL {
+					true => (&params.address, &code_address),
+					false => (&params.address, &params.address)
+				};
+
 				let can_call = ext.balance(&params.address) >= value && ext.depth() < ext.schedule().max_depth;
 
 				if !can_call {
@@ -636,7 +636,7 @@ impl Interpreter {
 					// and we don't want to copy
 					let input = unsafe { ::std::mem::transmute(mem.read_slice(in_off, in_size)) };
 					let output = mem.writeable_slice(out_off, out_size);
-					ext.call(&call_gas, address, &value, input, &code_address, output)
+					ext.call(&call_gas, sender_address, receive_address, Some(&value), input, &code_address, output)
 				};
 
 				return match call_result {

src/evm/tests.rs

@@ -61,22 +61,15 @@ impl Ext for FakeExt {
 
 	fn call(&mut self, 
 			_gas: &U256, 
-			_address: &Address, 
-			_value: &U256, 
+			_sender_address: &Address, 
+			_receive_address: &Address, 
+			_value: Option<&U256>,
 			_data: &[u8], 
 			_code_address: &Address, 
 			_output: &mut [u8]) -> MessageCallResult {
 		unimplemented!();
 	}
 
-	fn delegatecall(&mut self, 
-			_gas: &U256, 
-			_data: &[u8], 
-			_address: &Address, 
-			_output: &mut [u8]) -> MessageCallResult {
-		unimplemented!();
-	}
-
 	fn extcode(&self, address: &Address) -> Bytes {
 		self.codes.get(address).unwrap_or(&Bytes::new()).clone()
 	}