|
|
#![allow(dead_code)]
use std::collections::HashMap;
pub mod opcodes;
pub mod u256;
#[derive(Default)]
pub struct Stack {
pub pc: usize,
pub calldata_i: usize,
pub calldata_size: usize,
pub stack: Vec<[u8; 32]>,
pub storage: HashMap<[u8; 32], Vec<u8>>,
pub mem: Vec<u8>,
pub gas: u64,
pub opcodes: HashMap<u8, opcodes::Opcode>,
}
impl Stack {
pub fn new() -> Stack {
let mut s = Stack {
pc: 0,
calldata_i: 0,
calldata_size: 32,
stack: Vec::new(),
storage: HashMap::new(),
mem: Vec::new(),
gas: 10000000000,
opcodes: HashMap::new(),
};
s.opcodes = opcodes::new_opcodes();
s
}
pub fn print_stack(&self) {
println!("stack ({}):", self.stack.len());
for i in (0..self.stack.len()).rev() {
// println!("{:x}", &self.stack[i][28..]);
println!("{:?}", vec_u8_to_hex(self.stack[i].to_vec()));
}
}
pub fn print_memory(&self) {
if !self.mem.is_empty() {
println!("memory ({}):", self.mem.len());
println!("{:?}", vec_u8_to_hex(self.mem.to_vec()));
}
}
pub fn print_storage(&self) {
if !self.storage.is_empty() {
println!("storage ({}):", self.storage.len());
for (key, value) in self.storage.iter() {
println!(
"{:?}: {:?}",
vec_u8_to_hex(key.to_vec()),
vec_u8_to_hex(value.to_vec())
);
}
}
}
pub fn push(&mut self, b: [u8; 32]) {
self.stack.push(b);
}
// push_arbitrary performs a push, but first converting the arbitrary-length
// input into a 32 byte array
pub fn push_arbitrary(&mut self, b: &[u8]) {
// TODO if b.len()>32 return error
let mut d: [u8; 32] = [0; 32];
d[32 - b.len()..].copy_from_slice(b);
self.stack.push(d);
}
// put_arbitrary puts in the last element of the stack the value
pub fn put_arbitrary(&mut self, b: &[u8]) {
// TODO if b.len()>32 return error
let mut d: [u8; 32] = [0; 32];
d[0..b.len()].copy_from_slice(b); // put without left padding
let l = self.stack.len();
self.stack[l - 1] = d;
}
pub fn pop(&mut self) -> Result<[u8; 32], String> {
match self.stack.pop() {
Some(x) => Ok(x),
None => Err("pop err".to_string()), // WIP
}
}
pub fn peek(&mut self) -> Result<[u8; 32], String> {
if self.stack.is_empty() {
return Err("peek err".to_string());
}
Ok(self.stack[self.stack.len() - 1])
}
pub fn substract_gas(&mut self, val: u64) -> Result<(), String> {
if self.gas < val {
return Err("out of gas".to_string());
}
self.gas -= val;
Ok(())
}
pub fn execute(
&mut self,
code: &[u8],
calldata: &[u8],
debug: bool,
) -> Result<Vec<u8>, String> {
self.pc = 0;
self.calldata_i = 0;
let l = code.len();
while self.pc < l {
let opcode = code[self.pc];
if !self.opcodes.contains_key(&opcode) {
return Err(format!("invalid opcode {:x}", opcode));
}
if debug {
println!(
"{} (0x{:x}): pc={:?} gas={:?}",
self.opcodes.get(&opcode).unwrap().name,
opcode,
self.pc,
self.gas,
);
self.print_stack();
self.print_memory();
self.print_storage();
println!();
}
match opcode & 0xf0 {
0x00 => {
// arithmetic
match opcode {
0x00 => {
println!("0x00: STOP");
return Ok(Vec::new());
}
0x01 => self.add()?,
0x02 => self.mul()?,
0x03 => self.sub()?,
0x04 => self.div()?,
0x05 => self.sdiv()?,
0x06 => self.modulus()?,
0x07 => self.smod()?,
0x08 => self.add_mod()?,
0x09 => self.mul_mod()?,
0x0a => self.exp()?,
// 0x0b => self.sign_extend(),
_ => return Err(format!("unimplemented {:x}", opcode)),
}
self.pc += 1;
}
0x10 => {
// arithmetic
match opcode {
0x10 => self.lt()?,
0x11 => self.gt()?,
// 0x12 => self.slt()?,
// 0x13 => self.sgt()?,
0x14 => self.eq()?,
0x15 => self.is_zero()?,
0x16 => self.and()?,
0x17 => self.or()?,
0x18 => self.xor()?,
0x19 => self.not()?,
// 0x1a => self.byte()?,
_ => return Err(format!("unimplemented {:x}", opcode)),
}
self.pc += 1;
}
0x30 => {
match opcode {
0x35 => self.calldata_load(&calldata)?,
0x36 => self.calldata_size(&calldata),
0x39 => self.code_copy(&code)?,
_ => return Err(format!("unimplemented {:x}", opcode)),
}
self.pc += 1;
}
0x50 => {
self.pc += 1;
match opcode {
0x51 => self.mload()?,
0x52 => self.mstore()?,
0x55 => self.sstore()?,
0x56 => self.jump(code)?,
0x57 => self.jump_i(code)?,
0x5b => self.jump_dest()?,
_ => return Err(format!("unimplemented {:x}", opcode)),
}
}
0x60 | 0x70 => {
// push
let n = (opcode - 0x5f) as usize;
self.push_arbitrary(&code[self.pc + 1..self.pc + 1 + n]);
self.pc += 1 + n;
}
0x80 => {
// 0x8x dup
let l = self.stack.len();
if opcode > 0x7f {
self.stack.push(self.stack[l - (opcode - 0x7f) as usize]);
} else {
self.stack.push(self.stack[(0x7f - opcode) as usize]);
}
self.pc += 1;
}
0x90 => {
// 0x9x swap
let l = self.stack.len();
let pos;
if opcode > 0x8e {
pos = l - (opcode - 0x8e) as usize;
} else {
pos = (0x8e - opcode) as usize;
}
self.stack.swap(pos, l - 1);
self.pc += 1;
}
0xf0 => {
if opcode == 0xf3 {
let pos_to_return = u256::u256_to_u64(self.pop()?) as usize;
let len_to_return = u256::u256_to_u64(self.pop()?) as usize;
return Ok(self.mem[pos_to_return..pos_to_return + len_to_return].to_vec());
}
}
_ => {
return Err(format!("unimplemented {:x}", opcode));
}
}
self.substract_gas(self.opcodes.get(&opcode).unwrap().gas)?;
}
Ok(Vec::new())
}
}
pub fn vec_u8_to_hex(bytes: Vec<u8>) -> String {
let strs: Vec<String> = bytes.iter().map(|b| format!("{:02X}", b)).collect();
strs.join("")
}
|
