Merge pull request #596 from mir-protocol/evm_interpreter

EVM interpreter

evm/src/cpu/kernel/aggregator.rs

@@ -23,7 +23,14 @@ pub(crate) fn combined_kernel() -> Kernel {
 
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
+    use anyhow::Result;
+    use ethereum_types::U256;
+    use rand::{thread_rng, Rng};
+
     use crate::cpu::kernel::aggregator::combined_kernel;
+    use crate::cpu::kernel::interpreter::run;
 
     #[test]
     fn make_kernel() {
@@ -31,4 +38,171 @@ mod tests {
         let kernel = combined_kernel();
         println!("Kernel size: {} bytes", kernel.code.len());
     }
+
+    fn u256ify<'a>(hexes: impl IntoIterator<Item = &'a str>) -> Result<Vec<U256>> {
+        Ok(hexes
+            .into_iter()
+            .map(U256::from_str)
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+    #[test]
+    fn test_exp() -> Result<()> {
+        // Make sure we can parse and assemble the entire kernel.
+        let kernel = combined_kernel();
+        let exp = kernel.global_labels["exp"];
+        let mut rng = thread_rng();
+        let a = U256([0; 4].map(|_| rng.gen()));
+        let b = U256([0; 4].map(|_| rng.gen()));
+
+        // Random input
+        let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, a];
+        let stack_with_kernel = run(&kernel.code, exp, initial_stack);
+        let initial_stack = vec![b, a];
+        let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
+        let stack_with_opcode = run(&code, 0, initial_stack);
+        assert_eq!(stack_with_kernel, stack_with_opcode);
+
+        // 0 base
+        let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, U256::zero()];
+        let stack_with_kernel = run(&kernel.code, exp, initial_stack);
+        let initial_stack = vec![b, U256::zero()];
+        let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
+        let stack_with_opcode = run(&code, 0, initial_stack);
+        assert_eq!(stack_with_kernel, stack_with_opcode);
+
+        // 0 exponent
+        let initial_stack = vec![U256::from_str("0xdeadbeef")?, U256::zero(), a];
+        let stack_with_kernel = run(&kernel.code, exp, initial_stack);
+        let initial_stack = vec![U256::zero(), a];
+        let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
+        let stack_with_opcode = run(&code, 0, initial_stack);
+        assert_eq!(stack_with_kernel, stack_with_opcode);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_ec_ops() -> Result<()> {
+        // Make sure we can parse and assemble the entire kernel.
+        let kernel = combined_kernel();
+        let ec_add = kernel.global_labels["ec_add"];
+        let ec_double = kernel.global_labels["ec_double"];
+        let ec_mul = kernel.global_labels["ec_mul"];
+        let identity = ("0x0", "0x0");
+        let invalid = ("0x0", "0x3"); // Not on curve
+        let point0 = (
+            "0x1feee7ec986e198890cb83be8b8ba09ee953b3f149db6d9bfdaa5c308a33e58d",
+            "0x2051cc9a9edd46231604fd88f351e95ec72a285be93e289ac59cb48561efb2c6",
+        );
+        let point1 = (
+            "0x15b64d0a5f329fb672029298be8050f444626e6de11903caffa74b388075be1b",
+            "0x2d9e07340bd5cd7b70687b98f2500ff930a89a30d7b6a3e04b1b4d345319d234",
+        );
+        // point2 = point0 + point1
+        let point2 = (
+            "0x18659c0e0a8fedcb8747cf463fc7cfa05f667d84e771d0a9521fc1a550688f0c",
+            "0x283ed10b42703e187e7a808aeb45c6b457bc4cc7d704e53b3348a1e3b0bfa55b",
+        );
+        // point3 = 2 * point0
+        let point3 = (
+            "0x17da2b7b1a01c8dfdf0f5a6415833c7d755d219aa7e2c4cd0ac83d87d0ca4217",
+            "0xc9ace9de14aac8114541b50c19320eb40f0eeac3621526d9e34dbcf4c3a6c0f",
+        );
+        let s = "0xabb2a34c0e7956cfe6cef9ddb7e810c45ea19a6ebadd79c21959af09f5ba480a";
+        // point4 = s * point0
+        let point4 = (
+            "0xe519344959cc17021fe98878f947f5c1b1675325533a620c1684cfa6367e6c0",
+            "0x7496a7575b0b6a821e19ce780ecc3e0b156e605327798693defeb9f265b7a6f",
+        );
+
+        // Standard addition #1
+        let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point2.1, point2.0])?);
+        // Standard addition #2
+        let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point2.1, point2.0])?);
+
+        // Standard doubling #1
+        let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point3.1, point3.0])?);
+        // Standard doubling #2
+        let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_double, initial_stack);
+        assert_eq!(stack, u256ify([point3.1, point3.0])?);
+        // Standard doubling #3
+        let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, u256ify([point3.1, point3.0])?);
+
+        // Addition with identity #1
+        let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point1.1, point1.0])?);
+        // Addition with identity #2
+        let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point1.1, point1.0])?);
+        // Addition with identity #3
+        let initial_stack =
+            u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([identity.1, identity.0])?);
+
+        // Addition with invalid point(s) #1
+        let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, invalid.1, invalid.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, vec![U256::MAX, U256::MAX]);
+        // Addition with invalid point(s) #2
+        let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, vec![U256::MAX, U256::MAX]);
+        // Addition with invalid point(s) #3
+        let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, identity.1, identity.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, vec![U256::MAX, U256::MAX]);
+        // Addition with invalid point(s) #4
+        let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, invalid.1, invalid.0])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, vec![U256::MAX, U256::MAX]);
+
+        // Scalar multiplication #1
+        let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, u256ify([point4.1, point4.0])?);
+        // Scalar multiplication #2
+        let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, u256ify([identity.1, identity.0])?);
+        // Scalar multiplication #3
+        let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, u256ify([point0.1, point0.0])?);
+        // Scalar multiplication #4
+        let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, u256ify([identity.1, identity.0])?);
+        // Scalar multiplication #5
+        let initial_stack = u256ify(["0xdeadbeef", s, invalid.1, invalid.0])?;
+        let stack = run(&kernel.code, ec_mul, initial_stack);
+        assert_eq!(stack, vec![U256::MAX, U256::MAX]);
+
+        // Multiple calls
+        let ec_mul_hex = format!("0x{:x}", ec_mul);
+        let initial_stack = u256ify([
+            "0xdeadbeef",
+            s,
+            &ec_mul_hex,
+            identity.1,
+            identity.0,
+            point0.1,
+            point0.0,
+        ])?;
+        let stack = run(&kernel.code, ec_add, initial_stack);
+        assert_eq!(stack, u256ify([point4.1, point4.0])?);
+
+        Ok(())
+    }
 }

evm/src/cpu/kernel/asm/exp.asm

@@ -10,6 +10,7 @@
 /// Note that this correctly handles exp(0, 0) == 1.
 
 global exp:
+    jumpdest
     // stack: x, e, retdest
     dup2
     // stack: e, x, e, retdest
@@ -26,6 +27,7 @@ global exp:
     jump
 
 step_case:
+    jumpdest
     // stack: x, e, retdest
     push recursion_return
     // stack: recursion_return, x, e, retdest
@@ -41,6 +43,7 @@ step_case:
     // stack: x * x, e / 2, recursion_return, x, e, retdest
     %jump(exp)
 recursion_return:
+    jumpdest
     // stack: exp(x * x, e / 2), x, e, retdest
     push 2
     // stack: 2, exp(x * x, e / 2), x, e, retdest

evm/src/cpu/kernel/assembler.rs

@@ -16,7 +16,7 @@ const BYTES_PER_OFFSET: u8 = 3;
 #[derive(PartialEq, Eq, Debug)]
 pub struct Kernel {
     pub code: Vec<u8>,
-    global_labels: HashMap<String, usize>,
+    pub(crate) global_labels: HashMap<String, usize>,
 }
 
 struct Macro {

evm/src/cpu/kernel/interpreter.rs

@@ -0,0 +1,286 @@
+use ethereum_types::{U256, U512};
+
+struct Interpreter<'a> {
+    code: &'a [u8],
+    offset: usize,
+    stack: Vec<U256>,
+}
+
+pub fn run(code: &[u8], initial_offset: usize, initial_stack: Vec<U256>) -> Vec<U256> {
+    let mut interpreter = Interpreter {
+        code,
+        offset: initial_offset,
+        stack: initial_stack,
+    };
+    // Halt the execution if a jump to 0xdeadbeef was done.
+    while interpreter.offset != 0xdeadbeef {
+        interpreter.run_opcode();
+    }
+    interpreter.stack
+}
+
+impl<'a> Interpreter<'a> {
+    fn slice(&self, n: usize) -> &[u8] {
+        &self.code[self.offset..self.offset + n]
+    }
+
+    fn incr(&mut self, n: usize) {
+        self.offset += n;
+    }
+
+    fn push(&mut self, x: U256) {
+        self.stack.push(x);
+    }
+
+    fn push_bool(&mut self, x: bool) {
+        self.stack.push(if x { U256::one() } else { U256::zero() });
+    }
+
+    fn pop(&mut self) -> U256 {
+        self.stack.pop().expect("Pop on empty stack.")
+    }
+
+    fn run_opcode(&mut self) {
+        let opcode = self.code[self.offset];
+        self.incr(1);
+        match opcode {
+            0x00 => todo!(),                                           // "STOP",
+            0x01 => self.run_add(),                                    // "ADD",
+            0x02 => self.run_mul(),                                    // "MUL",
+            0x03 => self.run_sub(),                                    // "SUB",
+            0x04 => self.run_div(),                                    // "DIV",
+            0x05 => todo!(),                                           // "SDIV",
+            0x06 => self.run_mod(),                                    // "MOD",
+            0x07 => todo!(),                                           // "SMOD",
+            0x08 => self.run_addmod(),                                 // "ADDMOD",
+            0x09 => self.run_mulmod(),                                 // "MULMOD",
+            0x0a => self.run_exp(),                                    // "EXP",
+            0x0b => todo!(),                                           // "SIGNEXTEND",
+            0x10 => self.run_lt(),                                     // "LT",
+            0x11 => self.run_gt(),                                     // "GT",
+            0x12 => todo!(),                                           // "SLT",
+            0x13 => todo!(),                                           // "SGT",
+            0x14 => self.run_eq(),                                     // "EQ",
+            0x15 => self.run_iszero(),                                 // "ISZERO",
+            0x16 => self.run_and(),                                    // "AND",
+            0x17 => self.run_or(),                                     // "OR",
+            0x18 => self.run_xor(),                                    // "XOR",
+            0x19 => self.run_not(),                                    // "NOT",
+            0x1a => todo!(),                                           // "BYTE",
+            0x1b => todo!(),                                           // "SHL",
+            0x1c => todo!(),                                           // "SHR",
+            0x1d => todo!(),                                           // "SAR",
+            0x20 => todo!(),                                           // "KECCAK256",
+            0x30 => todo!(),                                           // "ADDRESS",
+            0x31 => todo!(),                                           // "BALANCE",
+            0x32 => todo!(),                                           // "ORIGIN",
+            0x33 => todo!(),                                           // "CALLER",
+            0x34 => todo!(),                                           // "CALLVALUE",
+            0x35 => todo!(),                                           // "CALLDATALOAD",
+            0x36 => todo!(),                                           // "CALLDATASIZE",
+            0x37 => todo!(),                                           // "CALLDATACOPY",
+            0x38 => todo!(),                                           // "CODESIZE",
+            0x39 => todo!(),                                           // "CODECOPY",
+            0x3a => todo!(),                                           // "GASPRICE",
+            0x3b => todo!(),                                           // "EXTCODESIZE",
+            0x3c => todo!(),                                           // "EXTCODECOPY",
+            0x3d => todo!(),                                           // "RETURNDATASIZE",
+            0x3e => todo!(),                                           // "RETURNDATACOPY",
+            0x3f => todo!(),                                           // "EXTCODEHASH",
+            0x40 => todo!(),                                           // "BLOCKHASH",
+            0x41 => todo!(),                                           // "COINBASE",
+            0x42 => todo!(),                                           // "TIMESTAMP",
+            0x43 => todo!(),                                           // "NUMBER",
+            0x44 => todo!(),                                           // "DIFFICULTY",
+            0x45 => todo!(),                                           // "GASLIMIT",
+            0x46 => todo!(),                                           // "CHAINID",
+            0x48 => todo!(),                                           // "BASEFEE",
+            0x50 => self.run_pop(),                                    // "POP",
+            0x51 => todo!(),                                           // "MLOAD",
+            0x52 => todo!(),                                           // "MSTORE",
+            0x53 => todo!(),                                           // "MSTORE8",
+            0x54 => todo!(),                                           // "SLOAD",
+            0x55 => todo!(),                                           // "SSTORE",
+            0x56 => self.run_jump(),                                   // "JUMP",
+            0x57 => self.run_jumpi(),                                  // "JUMPI",
+            0x58 => todo!(),                                           // "GETPC",
+            0x59 => todo!(),                                           // "MSIZE",
+            0x5a => todo!(),                                           // "GAS",
+            0x5b => (),                                                // "JUMPDEST",
+            x if (0x60..0x80).contains(&x) => self.run_push(x - 0x5f), // "PUSH"
+            x if (0x80..0x90).contains(&x) => self.run_dup(x - 0x7f),  // "DUP"
+            x if (0x90..0xa0).contains(&x) => self.run_swap(x - 0x8f), // "SWAP"
+            0xa0 => todo!(),                                           // "LOG0",
+            0xa1 => todo!(),                                           // "LOG1",
+            0xa2 => todo!(),                                           // "LOG2",
+            0xa3 => todo!(),                                           // "LOG3",
+            0xa4 => todo!(),                                           // "LOG4",
+            0xf0 => todo!(),                                           // "CREATE",
+            0xf1 => todo!(),                                           // "CALL",
+            0xf2 => todo!(),                                           // "CALLCODE",
+            0xf3 => todo!(),                                           // "RETURN",
+            0xf4 => todo!(),                                           // "DELEGATECALL",
+            0xf5 => todo!(),                                           // "CREATE2",
+            0xfa => todo!(),                                           // "STATICCALL",
+            0xfd => todo!(),                                           // "REVERT",
+            0xfe => todo!(),                                           // "INVALID",
+            0xff => todo!(),                                           // "SELFDESTRUCT",
+            _ => panic!("Unrecognized opcode {}.", opcode),
+        };
+    }
+
+    fn run_add(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x.overflowing_add(y).0);
+    }
+
+    fn run_mul(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x.overflowing_mul(y).0);
+    }
+
+    fn run_sub(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x.overflowing_sub(y).0);
+    }
+
+    fn run_div(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(if y.is_zero() { U256::zero() } else { x / y });
+    }
+
+    fn run_mod(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(if y.is_zero() { U256::zero() } else { x % y });
+    }
+
+    fn run_addmod(&mut self) {
+        let x = U512::from(self.pop());
+        let y = U512::from(self.pop());
+        let z = U512::from(self.pop());
+        self.push(if z.is_zero() {
+            U256::zero()
+        } else {
+            U256::try_from((x + y) % z).unwrap()
+        });
+    }
+
+    fn run_mulmod(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        let z = U512::from(self.pop());
+        self.push(if z.is_zero() {
+            U256::zero()
+        } else {
+            U256::try_from(x.full_mul(y) % z).unwrap()
+        });
+    }
+
+    fn run_exp(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x.overflowing_pow(y).0);
+    }
+
+    fn run_lt(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push_bool(x < y);
+    }
+
+    fn run_gt(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push_bool(x > y);
+    }
+
+    fn run_eq(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push_bool(x == y);
+    }
+
+    fn run_iszero(&mut self) {
+        let x = self.pop();
+        self.push_bool(x.is_zero());
+    }
+
+    fn run_and(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x & y);
+    }
+
+    fn run_or(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x | y);
+    }
+
+    fn run_xor(&mut self) {
+        let x = self.pop();
+        let y = self.pop();
+        self.push(x ^ y);
+    }
+
+    fn run_not(&mut self) {
+        let x = self.pop();
+        self.push(!x);
+    }
+
+    fn run_pop(&mut self) {
+        self.pop();
+    }
+
+    fn run_jump(&mut self) {
+        let x = self.pop().as_usize();
+        self.offset = x;
+        if let Some(&landing_opcode) = self.code.get(self.offset) {
+            assert_eq!(landing_opcode, 0x5b, "Destination is not a JUMPDEST.");
+        }
+    }
+
+    fn run_jumpi(&mut self) {
+        let x = self.pop().as_usize();
+        let b = self.pop();
+        if !b.is_zero() {
+            self.offset = x;
+            if let Some(&landing_opcode) = self.code.get(self.offset) {
+                assert_eq!(landing_opcode, 0x5b, "Destination is not a JUMPDEST.");
+            }
+        }
+    }
+
+    fn run_push(&mut self, num_bytes: u8) {
+        let x = U256::from_big_endian(self.slice(num_bytes as usize));
+        self.incr(num_bytes as usize);
+        self.push(x);
+    }
+
+    fn run_dup(&mut self, n: u8) {
+        self.push(self.stack[self.stack.len() - n as usize]);
+    }
+
+    fn run_swap(&mut self, n: u8) {
+        let len = self.stack.len();
+        self.stack.swap(len - 1, len - n as usize - 1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::cpu::kernel::interpreter::run;
+
+    #[test]
+    fn test_run() {
+        let code = vec![
+            0x60, 0x1, 0x60, 0x2, 0x1, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56,
+        ]; // PUSH1, 1, PUSH1, 2, ADD, PUSH4 deadbeef, JUMP
+        assert_eq!(run(&code, 0, vec![]), vec![0x3.into()]);
+    }
+}

evm/src/cpu/kernel/mod.rs

@@ -4,6 +4,9 @@ mod ast;
 mod opcodes;
 mod parser;
 
+#[cfg(test)]
+mod interpreter;
+
 use assembler::assemble;
 use parser::parse;