diff --git a/src/evm/evm.rs b/src/evm/evm.rs index fd6e59f6e..f26dff5e6 100644 --- a/src/evm/evm.rs +++ b/src/evm/evm.rs @@ -12,6 +12,9 @@ pub enum Error { /// was invalid. Balance still should be transfered and nonce /// should be increased. OutOfGas, + /// `BadJumpDestination` is returned when execution tried to move + /// to position that wasn't marked with JUMPDEST instruction + BadJumpDestination, /// Returned on evm internal error. Should never be ignored during development. /// Likely to cause consensus issues. Internal, diff --git a/src/evm/ext.rs b/src/evm/ext.rs index b878c5819..da65d7075 100644 --- a/src/evm/ext.rs +++ b/src/evm/ext.rs @@ -44,7 +44,7 @@ pub trait Ext { fn extcode(&self, address: &Address) -> Vec; /// Creates log entry with given topics and data - fn log(&mut self, topics: Vec, data: Bytes); + fn log(&mut self, topics: Vec, data: &[u8]); /// Should be called when transaction calls `RETURN` opcode. /// Returns gas_left if cost of returning the data is not too high. diff --git a/src/evm/factory.rs b/src/evm/factory.rs index 788140a38..67ffe9766 100644 --- a/src/evm/factory.rs +++ b/src/evm/factory.rs @@ -15,7 +15,7 @@ impl Factory { /// Returns native rust evm #[cfg(not(feature = "jit"))] pub fn create() -> Box { - unimplemented!(); + Box::new(super::interpreter::Interpreter::new()) } } diff --git a/src/evm/instructions.rs b/src/evm/instructions.rs new file mode 100644 index 000000000..6b1876574 --- /dev/null +++ b/src/evm/instructions.rs @@ -0,0 +1,180 @@ +//! VM Instructions list and utility functions + +pub type Instruction = u8; + +pub fn is_jump (i : Instruction) -> bool { + i == JUMP || i == JUMPI || i == JUMPDEST +} + +pub fn is_push (i : Instruction) -> bool { + i >= PUSH1 && i <= PUSH32 +} + +pub fn get_push_bytes (i : Instruction) -> usize { + // TODO [todr] range checking? + (i - PUSH1 + 1) as usize +} + +pub fn get_dup_position (i: Instruction) -> usize { + // TODO [todr] range checking? + (i - DUP1) as usize +} + +pub fn get_swap_position (i : Instruction) -> usize { + // TODO [todr] range checking? + (i - SWAP1 + 1) as usize +} + +pub fn get_log_topics (i: Instruction) -> usize { + (i - LOG0) as usize +} + +#[test] +fn test_get_push_bytes() { + assert_eq!(get_push_bytes(PUSH1), 1); + assert_eq!(get_push_bytes(PUSH3), 3); + assert_eq!(get_push_bytes(PUSH32), 32); +} + +// Virtual machine bytecode instruction. +pub const STOP: Instruction = 0x00; //< halts execution +pub const ADD: Instruction = 0x01; //< addition operation +pub const MUL: Instruction = 0x02; //< mulitplication operation +pub const SUB: Instruction = 0x03; //< subtraction operation +pub const DIV: Instruction = 0x04; //< integer division operation +pub const SDIV: Instruction = 0x05; //< signed integer division operation +pub const MOD: Instruction = 0x06; //< modulo remainder operation +pub const SMOD: Instruction = 0x07; //< signed modulo remainder operation +pub const ADDMOD: Instruction = 0x08; //< unsigned modular addition +pub const MULMOD: Instruction = 0x09; //< unsigned modular multiplication +pub const EXP: Instruction = 0x0a; //< exponential operation +pub const SIGNEXTEND: Instruction = 0x0b; //< extend length of signed integer + +pub const LT: Instruction = 0x10; //< less-than comparision +pub const GT: Instruction = 0x11; //< greater-than comparision +pub const SLT: Instruction = 0x12; //< signed less-than comparision +pub const SGT: Instruction = 0x13; //< signed greater-than comparision +pub const EQ: Instruction = 0x14; //< equality comparision +pub const ISZERO: Instruction = 0x15; //< simple not operator +pub const AND: Instruction = 0x16; //< bitwise AND operation +pub const OR: Instruction = 0x17; //< bitwise OR operation +pub const XOR: Instruction = 0x18; //< bitwise XOR operation +pub const NOT: Instruction = 0x19; //< bitwise NOT opertation +pub const BYTE: Instruction = 0x1a; //< retrieve single byte from word + +pub const SHA3: Instruction = 0x20; //< compute SHA3-256 hash + +pub const ADDRESS: Instruction = 0x30; //< get address of currently executing account +pub const BALANCE: Instruction = 0x31; //< get balance of the given account +pub const ORIGIN: Instruction = 0x32; //< get execution origination address +pub const CALLER: Instruction = 0x33; //< get caller address +pub const CALLVALUE: Instruction = 0x34; //< get deposited value by the instruction/transaction responsible for this execution +pub const CALLDATALOAD: Instruction = 0x35; //< get input data of current environment +pub const CALLDATASIZE: Instruction = 0x36; //< get size of input data in current environment +pub const CALLDATACOPY: Instruction = 0x37; //< copy input data in current environment to memory +pub const CODESIZE: Instruction = 0x38; //< get size of code running in current environment +pub const CODECOPY: Instruction = 0x39; //< copy code running in current environment to memory +pub const GASPRICE: Instruction = 0x3a; //< get price of gas in current environment +pub const EXTCODESIZE: Instruction = 0x3b; //< get external code size (from another contract) +pub const EXTCODECOPY: Instruction = 0x3c; //< copy external code (from another contract) + +pub const BLOCKHASH: Instruction = 0x40; //< get hash of most recent complete block +pub const COINBASE: Instruction = 0x41; //< get the block's coinbase address +pub const TIMESTAMP: Instruction = 0x42; //< get the block's timestamp +pub const NUMBER: Instruction = 0x43; //< get the block's number +pub const DIFFICULTY: Instruction = 0x44; //< get the block's difficulty +pub const GASLIMIT: Instruction = 0x45; //< get the block's gas limit + +pub const POP: Instruction = 0x50; //< remove item from stack +pub const MLOAD: Instruction = 0x51; //< load word from memory +pub const MSTORE: Instruction = 0x52; //< save word to memory +pub const MSTORE8: Instruction = 0x53; //< save byte to memory +pub const SLOAD: Instruction = 0x54; //< load word from storage +pub const SSTORE: Instruction = 0x55; //< save word to storage +pub const JUMP: Instruction = 0x56; //< alter the program counter +pub const JUMPI: Instruction = 0x57; //< conditionally alter the program counter +pub const PC: Instruction = 0x58; //< get the program counter +pub const MSIZE: Instruction = 0x59; //< get the size of active memory +pub const GAS: Instruction = 0x5a; //< get the amount of available gas +pub const JUMPDEST: Instruction = 0x5b; //< set a potential jump destination + +pub const PUSH1: Instruction = 0x60; //< place 1 byte item on stack +pub const PUSH2: Instruction = 0x61; //< place 2 byte item on stack +pub const PUSH3: Instruction = 0x62; //< place 3 byte item on stack +pub const PUSH4: Instruction = 0x63; //< place 4 byte item on stack +pub const PUSH5: Instruction = 0x64; //< place 5 byte item on stack +pub const PUSH6: Instruction = 0x65; //< place 6 byte item on stack +pub const PUSH7: Instruction = 0x66; //< place 7 byte item on stack +pub const PUSH8: Instruction = 0x67; //< place 8 byte item on stack +pub const PUSH9: Instruction = 0x68; //< place 9 byte item on stack +pub const PUSH10: Instruction = 0x69; //< place 10 byte item on stack +pub const PUSH11: Instruction = 0x6a; //< place 11 byte item on stack +pub const PUSH12: Instruction = 0x6b; //< place 12 byte item on stack +pub const PUSH13: Instruction = 0x6c; //< place 13 byte item on stack +pub const PUSH14: Instruction = 0x6d; //< place 14 byte item on stack +pub const PUSH15: Instruction = 0x6e; //< place 15 byte item on stack +pub const PUSH16: Instruction = 0x6f; //< place 16 byte item on stack +pub const PUSH17: Instruction = 0x70; //< place 17 byte item on stack +pub const PUSH18: Instruction = 0x71; //< place 18 byte item on stack +pub const PUSH19: Instruction = 0x72; //< place 19 byte item on stack +pub const PUSH20: Instruction = 0x73; //< place 20 byte item on stack +pub const PUSH21: Instruction = 0x74; //< place 21 byte item on stack +pub const PUSH22: Instruction = 0x75; //< place 22 byte item on stack +pub const PUSH23: Instruction = 0x76; //< place 23 byte item on stack +pub const PUSH24: Instruction = 0x77; //< place 24 byte item on stack +pub const PUSH25: Instruction = 0x78; //< place 25 byte item on stack +pub const PUSH26: Instruction = 0x79; //< place 26 byte item on stack +pub const PUSH27: Instruction = 0x7a; //< place 27 byte item on stack +pub const PUSH28: Instruction = 0x7b; //< place 28 byte item on stack +pub const PUSH29: Instruction = 0x7c; //< place 29 byte item on stack +pub const PUSH30: Instruction = 0x7d; //< place 30 byte item on stack +pub const PUSH31: Instruction = 0x7e; //< place 31 byte item on stack +pub const PUSH32: Instruction = 0x7f; //< place 32 byte item on stack + +pub const DUP1: Instruction = 0x80; //< copies the highest item in the stack to the top of the stack +pub const DUP2: Instruction = 0x81; //< copies the second highest item in the stack to the top of the stack +pub const DUP3: Instruction = 0x82; //< copies the third highest item in the stack to the top of the stack +pub const DUP4: Instruction = 0x83; //< copies the 4th highest item in the stack to the top of the stack +pub const DUP5: Instruction = 0x84; //< copies the 5th highest item in the stack to the top of the stack +pub const DUP6: Instruction = 0x85; //< copies the 6th highest item in the stack to the top of the stack +pub const DUP7: Instruction = 0x86; //< copies the 7th highest item in the stack to the top of the stack +pub const DUP8: Instruction = 0x87; //< copies the 8th highest item in the stack to the top of the stack +pub const DUP9: Instruction = 0x88; //< copies the 9th highest item in the stack to the top of the stack +pub const DUP10: Instruction = 0x89; //< copies the 10th highest item in the stack to the top of the stack +pub const DUP11: Instruction = 0x8a; //< copies the 11th highest item in the stack to the top of the stack +pub const DUP12: Instruction = 0x8b; //< copies the 12th highest item in the stack to the top of the stack +pub const DUP13: Instruction = 0x8c; //< copies the 13th highest item in the stack to the top of the stack +pub const DUP14: Instruction = 0x8d; //< copies the 14th highest item in the stack to the top of the stack +pub const DUP15: Instruction = 0x8e; //< copies the 15th highest item in the stack to the top of the stack +pub const DUP16: Instruction = 0x8f; //< copies the 16th highest item in the stack to the top of the stack + +pub const SWAP1: Instruction = 0x90; //< swaps the highest and second highest value on the stack +pub const SWAP2: Instruction = 0x91; //< swaps the highest and third highest value on the stack +pub const SWAP3: Instruction = 0x92; //< swaps the highest and 4th highest value on the stack +pub const SWAP4: Instruction = 0x93; //< swaps the highest and 5th highest value on the stack +pub const SWAP5: Instruction = 0x94; //< swaps the highest and 6th highest value on the stack +pub const SWAP6: Instruction = 0x95; //< swaps the highest and 7th highest value on the stack +pub const SWAP7: Instruction = 0x96; //< swaps the highest and 8th highest value on the stack +pub const SWAP8: Instruction = 0x97; //< swaps the highest and 9th highest value on the stack +pub const SWAP9: Instruction = 0x98; //< swaps the highest and 10th highest value on the stack +pub const SWAP10: Instruction = 0x99; //< swaps the highest and 11th highest value on the stack +pub const SWAP11: Instruction = 0x9a; //< swaps the highest and 12th highest value on the stack +pub const SWAP12: Instruction = 0x9b; //< swaps the highest and 13th highest value on the stack +pub const SWAP13: Instruction = 0x9c; //< swaps the highest and 14th highest value on the stack +pub const SWAP14: Instruction = 0x9d; //< swaps the highest and 15th highest value on the stack +pub const SWAP15: Instruction = 0x9e; //< swaps the highest and 16th highest value on the stack +pub const SWAP16: Instruction = 0x9f; //< swaps the highest and 17th highest value on the stack + +pub const LOG0: Instruction = 0xa0; //< Makes a log entry; no topics. +pub const LOG1: Instruction = 0xa1; //< Makes a log entry; 1 topic. +pub const LOG2: Instruction = 0xa2; //< Makes a log entry; 2 topics. +pub const LOG3: Instruction = 0xa3; //< Makes a log entry; 3 topics. +pub const LOG4: Instruction = 0xa4; //< Makes a log entry; 4 topics. + +pub const CREATE: Instruction = 0xf0; //< create a new account with associated code +pub const CALL: Instruction = 0xf1; //< message-call into an account +pub const CALLCODE: Instruction = 0xf2; //< message-call with another account's code only +pub const RETURN: Instruction = 0xf3; //< halt execution returning output data +pub const DELEGATECALL: Instruction = 0xf4; //< like CALLCODE but keeps caller's value and sender +pub const SUICIDE: Instruction = 0xff; //< halt execution and register account for later deletion + diff --git a/src/evm/interpreter.rs b/src/evm/interpreter.rs new file mode 100644 index 000000000..19902e73e --- /dev/null +++ b/src/evm/interpreter.rs @@ -0,0 +1,326 @@ +///! Rust VM implementation + +use common::*; +use evm; +use super::schedule::Schedule; +use super::instructions as instructions; +use super::instructions::Instruction; + +type CodePosition = usize; +type Gas = U256; +type ProgramCounter = usize; + +/// Stack trait with VM-friendly API +trait Stack { + /// Returns `Stack[len(Stack) - no_from_top]` + fn peek(&self, no_from_top: usize) -> &T; + /// Swaps Stack[len(Stack)] and Stack[len(Stack) - no_from_top] + fn swap_with_top(&mut self, no_from_top: usize); + /// Returns true if Stack has at least `no_of_elems` elements + fn has(&self, no_of_elems: usize) -> bool; + /// Get element from top and remove it from Stack. Panics if stack is empty. + fn pop_back(&mut self) -> T; + /// Get elements from top and remove them from Stack. Panics if stack is empty. + fn pop_n(&mut self, no_of_elems: usize) -> Vec; + /// Add element on top of the Stack + fn push(&mut self, elem: T); +} +impl Stack for Vec { + fn peek(&self, no_from_top: usize) -> &S { + return &self[self.len() - no_from_top - 1]; + } + + fn swap_with_top(&mut self, no_from_top: usize) { + let len = self.len(); + self.swap(len - no_from_top - 1, len - 1); + } + + fn has(&self, no_of_elems: usize) -> bool { + self.len() >= no_of_elems + } + + fn pop_back(&mut self) -> S { + let val = self.pop(); + match val { + Some(x) => x, + None => panic!("Tried to pop from empty stack.") + } + } + + fn pop_n(&mut self, no_of_elems: usize) -> Vec { + let mut vec = Vec::new(); + for i in 1..no_of_elems { + vec.push(self.pop_back()); + } + vec + } + + + fn push(&mut self, elem: S) { + self.push(elem); + } +} +/// Abstraction over raw vector of Bytes. Easier state management of PC. +struct CodeReader<'a> { + position: ProgramCounter, + code: &'a Bytes +} +impl<'a> CodeReader<'a> { + /// Get `no_of_bytes` from code and convert to U256. Move PC + fn read(&mut self, no_of_bytes: usize) -> U256 { + self.position += no_of_bytes; + // TODO [todr] READ and return something usefull + U256::zero() + } + + /// Retrieve part of the code described by offset and size + fn get_slice(&self, init_off_u: U256, init_size_u: U256) -> &[u8] { + let init_off = init_off_u.low_u64() as usize; + let init_size = init_size_u.low_u64() as usize; + &self.code[self.position + init_off..self.position + init_off + init_size] + } + + /// Stop any further execution (move PC to the end) + fn stop_execution(&mut self) { + self.position = self.code.len(); + } +} + +pub struct Interpreter; + +impl evm::Evm for Interpreter { + fn exec(&self, params: &ActionParams, ext: &mut evm::Ext) -> evm::Result { + // TODO schedule? + // TODO reserve stack + + // let schedule = ext.schedule(); + let code = ¶ms.code; + let valid_jump_destinations = self.find_jump_destinations(&code); + + let mut gas = params.gas.clone(); + let mut stack = vec![]; + let mut reader = CodeReader { + position: 0, + code: &code + }; + + while reader.position < code.len() { + let instruction = code[reader.position]; + let gas_usage = self.check_and_get_gas_usage(instruction/*, schedule*/); + // TODO check if we have enough + + // Handle jumps + match instruction { + instructions::JUMP => { + let jump = stack.pop_back(); + reader.position = try!(self.verify_jump(jump, &valid_jump_destinations)); + }, + instructions::JUMPI => { + let condition = stack.pop_back(); + let jump = stack.pop_back(); + if !self.is_zero(condition) { + reader.position = try!(self.verify_jump(jump, &valid_jump_destinations)); + } + }, + instructions::JUMPDEST => { + // ignore + }, + _ => { + // Execute all other instructions + self.exec_instruction(params, ext, gas, instruction, &mut reader, &mut stack); + } + } + reader.position += 1; + } + Ok(gas) + } +} + +impl Interpreter { + + fn check_and_get_gas_usage(&self, instruction: Instruction/*, schedule: &Schedule*/) -> Gas { + U256::zero() + } + + fn exec_instruction(&self, + params: &ActionParams, + ext: &mut evm::Ext, + gas: Gas, + instruction: Instruction, + code: &mut CodeReader, + stack: &mut Stack + ) -> evm::Result { + match instruction { + instructions::CREATE => { + let endowment = stack.pop_back(); + let init_off = stack.pop_back(); + let init_size = stack.pop_back(); + + // TODO [todr] Fix u64 for gas + let contract_code = code.get_slice(init_off, init_size); + // TODO [todr] Fix u64 for gasLeft + let (gas_left, maybe_address) = try!(ext.create(gas.low_u64(), &endowment, &contract_code)); + match maybe_address { + Some(address) => stack.push(U256::from(address)), + None => stack.push(U256::zero()) + } + Ok(U256::from(gas_left)) + }, + // CALL, CALLCODE, DELEGATECALL + instructions::RETURN => { + let init_off = stack.pop_back(); + let init_size = stack.pop_back(); + code.stop_execution(); + let return_code = code.get_slice(init_off, init_size); + // TODO [todr] Fix u64 for gas + let gas_left = try!(ext.ret(gas.low_u64(), &return_code)); + // TODO [todr] Fix u64 for gasLeft + Ok(U256::from(gas_left)) + }, + instructions::STOP => { + code.stop_execution(); + Ok(gas) + }, + instructions::SUICIDE => { + // TODO [todr] Suicide should have argument with address of contract that funds should be transfered to + let address = stack.pop_back(); + // ext.suicide(Address::from(address)); + ext.suicide(); + code.stop_execution(); + Ok(gas) + }, + instructions::LOG0...instructions::LOG4 => { + let no_of_topics = instructions::get_log_topics(instruction); + let topics_data = stack.pop_n(no_of_topics + 2); + + let offset = topics_data[0]; + let size = topics_data[1]; + let topics = topics_data + .iter() + .skip(2) + .map(H256::from) + .collect(); + ext.log(topics, code.get_slice(offset, size)); + Ok(gas) + }, + instructions::PUSH1...instructions::PUSH32 => { + // Load to stack + let bytes = instructions::get_push_bytes(instruction); + let val = code.read(bytes); + stack.push(val); + Ok(gas) + }, + instructions::MLOAD => { + // TODO [ToDr] load word from mem? + Ok(gas) + }, + instructions::MSTORE => { + // TODO [ToDr] save word to mem? + Ok(gas) + }, + instructions::MSTORE8 => { + // TODO [ToDr] save byte to mem? + Ok(gas) + }, + instructions::MSIZE => { + // Size of memry to stack + Ok(gas) + }, + instructions::SLOAD => { + let key = H256::from(&stack.pop_back()); + let word = U256::from(ext.sload(&key).as_slice()); + stack.push(word); + Ok(gas) + }, + instructions::SSTORE => { + let key = H256::from(&stack.pop_back()); + let word = H256::from(&stack.pop_back()); + ext.sstore(key, word); + Ok(gas) + }, + instructions::PC => { + stack.push(U256::from(code.position)); + Ok(gas) + }, + instructions::GAS => { + stack.push(U256::from(gas)); + Ok(gas) + }, + _ => { + self.exec_stack_instruction(instruction, stack); + Ok(gas) + } + } + } + + fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &HashSet) -> Result { + let jump = jump_u.low_u64() as usize; + + if valid_jump_destinations.contains(&jump) { + Ok(jump) + } else { + Err(evm::Error::BadJumpDestination) + } + } + + fn is_zero(&self, val: U256) -> bool { + U256::zero() == val + } + + fn exec_stack_instruction(&self, instruction: Instruction, stack : &mut Stack) { + match instruction { + instructions::DUP1...instructions::DUP16 => { + let position = instructions::get_dup_position(instruction); + let val = stack.peek(position).clone(); + stack.push(val); + }, + instructions::SWAP1...instructions::SWAP16 => { + let position = instructions::get_swap_position(instruction); + stack.swap_with_top(position) + }, + instructions::ADD => { + let a = stack.pop_back(); + let b = stack.pop_back(); + stack.push(a + b); + }, + _ => panic!(format!("Unknown stack instruction: {:x}", instruction)) + } + } + + fn find_jump_destinations(&self, code : &Bytes) -> HashSet { + let mut jump_dests = HashSet::new(); + let mut position = 0; + + while position < code.len() { + let instruction = code[position]; + + if instruction == instructions::JUMPDEST { + jump_dests.insert(position); + } else if instructions::is_push(instruction) { + position += instructions::get_push_bytes(instruction); + } + position += 1; + } + + return jump_dests; + } +} + +#[cfg(test)] +mod tests { + use common::*; + use super::*; + + #[test] + fn test_find_jump_destinations() { + // given + let interpreter = Interpreter; + let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap(); + + // when + let valid_jump_destinations = interpreter.find_jump_destinations(&code); + + // then + assert!(valid_jump_destinations.contains(&66)); + } +} diff --git a/src/evm/jit.rs b/src/evm/jit.rs index fb71f3363..9965ed9a1 100644 --- a/src/evm/jit.rs +++ b/src/evm/jit.rs @@ -295,7 +295,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> { } let bytes_ref: &[u8] = slice::from_raw_parts(beg, size as usize); - self.ext.log(topics, bytes_ref.to_vec()); + self.ext.log(topics, bytes_ref); } } diff --git a/src/evm/mod.rs b/src/evm/mod.rs index ee590c934..118e98f8a 100644 --- a/src/evm/mod.rs +++ b/src/evm/mod.rs @@ -2,8 +2,10 @@ pub mod ext; pub mod evm; +pub mod interpreter; pub mod factory; pub mod schedule; +mod instructions; #[cfg(feature = "jit" )] mod jit; diff --git a/src/evm/tests.rs b/src/evm/tests.rs index e3f81dd93..9ec466359 100644 --- a/src/evm/tests.rs +++ b/src/evm/tests.rs @@ -26,7 +26,7 @@ impl FakeExt { } impl Ext for FakeExt { - fn sload(&self, key: &H256) -> H256 { + fn sload(&self, key: &H256) -> H256 { self.store.get(key).unwrap_or(&H256::new()).clone() } @@ -61,10 +61,10 @@ impl Ext for FakeExt { self.codes.get(address).unwrap_or(&Bytes::new()).clone() } - fn log(&mut self, topics: Vec, data: Bytes) { + fn log(&mut self, topics: Vec, data: &[u8]) { self.logs.push(FakeLogEntry { topics: topics, - data: data + data: data.to_vec() }); } @@ -86,8 +86,17 @@ impl Ext for FakeExt { } #[test] -fn test_add() { - let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap(); +#[cfg(feature = "jit")] +fn test_add_jit() { + test_add(Box::new(super::jit::JitEvm)); +} +#[test] +fn test_add_interpreter() { + test_add(Box::new(super::interpreter::Interpreter)); +} + +fn test_add(vm : Box) { + let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap(); let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01600055".from_hex().unwrap(); let mut params = ActionParams::new(); @@ -97,7 +106,6 @@ fn test_add() { let mut ext = FakeExt::new(); let gas_left = { - let vm = Factory::create(); vm.exec(¶ms, &mut ext).unwrap() }; diff --git a/src/executive.rs b/src/executive.rs index da0948d9e..5a5a835cf 100644 --- a/src/executive.rs +++ b/src/executive.rs @@ -206,7 +206,8 @@ impl<'a> Executive<'a> { fn finalize(&mut self, t: &Transaction, substate: Substate, backup: State, result: evm::Result) -> ExecutionResult { match result { Err(evm::Error::Internal) => Err(ExecutionError::Internal), - Err(evm::Error::OutOfGas) => { + // TODO [ToDr] BadJumpDestination @debris - how to handle that? + Err(evm::Error::OutOfGas) | Err(evm::Error::BadJumpDestination) => { *self.state = backup; Ok(Executed { gas: t.gas, @@ -426,9 +427,9 @@ impl<'a> Ext for Externalities<'a> { } } - fn log(&mut self, topics: Vec, data: Bytes) { + fn log(&mut self, topics: Vec, data: &[u8]) { let address = self.params.address.clone(); - self.substate.logs.push(LogEntry::new(address, topics, data)); + self.substate.logs.push(LogEntry::new(address, topics, data.to_vec())); } fn suicide(&mut self) {