logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-07 16:23:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

PANIC returns error

Browse Source
This commit is contained in:
Daniel Lubarov 2022-07-18 08:58:11 -07:00
parent d53804c66f
commit 0b7e3eca67
4 changed files with 57 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
evm/src/cpu/kernel/interpreter.rs
View File

@ -1,3 +1,4 @@
use anyhow::bail;
use ethereum_types::{U256, U512}; use ethereum_types::{U256, U512};
/// Halt interpreter execution whenever a jump to this offset is done. /// Halt interpreter execution whenever a jump to this offset is done.
@ -51,7 +52,11 @@ pub(crate) struct Interpreter<'a> {
running: bool, running: bool,
} }
pub(crate) fn run(code: &[u8], initial_offset: usize, initial_stack: Vec<U256>) -> Interpreter { pub(crate) fn run(
code: &[u8],
initial_offset: usize,
initial_stack: Vec<U256>,
) -> anyhow::Result<Interpreter> {
let mut interpreter = Interpreter { let mut interpreter = Interpreter {
code, code,
jumpdests: find_jumpdests(code), jumpdests: find_jumpdests(code),
@ -65,7 +70,7 @@ pub(crate) fn run(code: &[u8], initial_offset: usize, initial_stack: Vec<U256>)
interpreter.run_opcode(); interpreter.run_opcode();
} }
interpreter Ok(interpreter)
} }
impl<'a> Interpreter<'a> { impl<'a> Interpreter<'a> {
@ -89,7 +94,7 @@ impl<'a> Interpreter<'a> {
self.stack.pop().expect("Pop on empty stack.") self.stack.pop().expect("Pop on empty stack.")
} }
fn run_opcode(&mut self) { fn run_opcode(&mut self) -> anyhow::Result<()> {
let opcode = self.code.get(self.offset).copied().unwrap_or_default(); let opcode = self.code.get(self.offset).copied().unwrap_or_default();
self.incr(1); self.incr(1);
match opcode { match opcode {
@ -168,7 +173,7 @@ impl<'a> Interpreter<'a> {
0xa2 => todo!(), // "LOG2", 0xa2 => todo!(), // "LOG2",
0xa3 => todo!(), // "LOG3", 0xa3 => todo!(), // "LOG3",
0xa4 => todo!(), // "LOG4", 0xa4 => todo!(), // "LOG4",
0xa5 => panic!("Executed PANIC"), // "PANIC", 0xa5 => bail!("Executed PANIC"), // "PANIC",
0xf0 => todo!(), // "CREATE", 0xf0 => todo!(), // "CREATE",
0xf1 => todo!(), // "CALL", 0xf1 => todo!(), // "CALL",
0xf2 => todo!(), // "CALLCODE", 0xf2 => todo!(), // "CALLCODE",
@ -183,10 +188,11 @@ impl<'a> Interpreter<'a> {
0xfb => todo!(), // "MLOAD_GENERAL", 0xfb => todo!(), // "MLOAD_GENERAL",
0xfc => todo!(), // "MSTORE_GENERAL", 0xfc => todo!(), // "MSTORE_GENERAL",
0xfd => todo!(), // "REVERT", 0xfd => todo!(), // "REVERT",
0xfe => todo!(), // "INVALID", 0xfe => bail!("Executed INVALID"), // "INVALID",
0xff => todo!(), // "SELFDESTRUCT", 0xff => todo!(), // "SELFDESTRUCT",
_ => panic!("Unrecognized opcode {}.", opcode), _ => bail!("Unrecognized opcode {}.", opcode),
}; };
Ok(())
} }
fn run_stop(&mut self) { fn run_stop(&mut self) {
@ -381,15 +387,16 @@ mod tests {
use crate::cpu::kernel::interpreter::{run, Interpreter}; use crate::cpu::kernel::interpreter::{run, Interpreter};
#[test] #[test]
fn test_run() { fn test_run() -> anyhow::Result<()> {
let code = vec![ let code = vec![
0x60, 0x1, 0x60, 0x2, 0x1, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56, 0x60, 0x1, 0x60, 0x2, 0x1, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56,
]; // PUSH1, 1, PUSH1, 2, ADD, PUSH4 deadbeef, JUMP ]; // PUSH1, 1, PUSH1, 2, ADD, PUSH4 deadbeef, JUMP
assert_eq!(run(&code, 0, vec![]).stack, vec![0x3.into()]); assert_eq!(run(&code, 0, vec![])?.stack, vec![0x3.into()]);
Ok(())
} }
#[test] #[test]
fn test_run_with_memory() { fn test_run_with_memory() -> anyhow::Result<()> {
// PUSH1 0xff // PUSH1 0xff
// PUSH1 0 // PUSH1 0
// MSTORE // MSTORE
@ -407,9 +414,10 @@ mod tests {
0x60, 0xff, 0x60, 0x0, 0x52, 0x60, 0, 0x51, 0x60, 0x1, 0x51, 0x60, 0x42, 0x60, 0x27, 0x60, 0xff, 0x60, 0x0, 0x52, 0x60, 0, 0x51, 0x60, 0x1, 0x51, 0x60, 0x42, 0x60, 0x27,
0x53, 0x53,
]; ];
let run = run(&code, 0, vec![]); let run = run(&code, 0, vec![])?;
let Interpreter { stack, memory, .. } = run; let Interpreter { stack, memory, .. } = run;
assert_eq!(stack, vec![0xff.into(), 0xff00.into()]); assert_eq!(stack, vec![0xff.into(), 0xff00.into()]);
assert_eq!(&memory.memory, &hex!("00000000000000000000000000000000000000000000000000000000000000ff0000000000000042000000000000000000000000000000000000000000000000")); assert_eq!(&memory.memory, &hex!("00000000000000000000000000000000000000000000000000000000000000ff0000000000000042000000000000000000000000000000000000000000000000"));
Ok(())
} }
} }

62
evm/src/cpu/kernel/tests/curve_ops.rs
View File

@ -43,76 +43,76 @@ mod bn {
// Standard addition #1 // Standard addition #1
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point2.1, point2.0])?); assert_eq!(stack, u256ify([point2.1, point2.0])?);
// Standard addition #2 // Standard addition #2
let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point2.1, point2.0])?); assert_eq!(stack, u256ify([point2.1, point2.0])?);
// Standard doubling #1 // Standard doubling #1
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Standard doubling #2 // Standard doubling #2
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_double, initial_stack).stack; let stack = run(&kernel.code, ec_double, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Standard doubling #3 // Standard doubling #3
let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Addition with identity #1 // Addition with identity #1
let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?; let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point1.1, point1.0])?); assert_eq!(stack, u256ify([point1.1, point1.0])?);
// Addition with identity #2 // Addition with identity #2
let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?; let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point1.1, point1.0])?); assert_eq!(stack, u256ify([point1.1, point1.0])?);
// Addition with identity #3 // Addition with identity #3
let initial_stack = let initial_stack =
u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?; u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Addition with invalid point(s) #1 // Addition with invalid point(s) #1
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, invalid.1, invalid.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, invalid.1, invalid.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX, U256::MAX]); assert_eq!(stack, vec![U256::MAX, U256::MAX]);
// Addition with invalid point(s) #2 // Addition with invalid point(s) #2
let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX, U256::MAX]); assert_eq!(stack, vec![U256::MAX, U256::MAX]);
// Addition with invalid point(s) #3 // Addition with invalid point(s) #3
let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, identity.1, identity.0])?; let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX, U256::MAX]); assert_eq!(stack, vec![U256::MAX, U256::MAX]);
// Addition with invalid point(s) #4 // Addition with invalid point(s) #4
let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, invalid.1, invalid.0])?; let initial_stack = u256ify(["0xdeadbeef", invalid.1, invalid.0, invalid.1, invalid.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX, U256::MAX]); assert_eq!(stack, vec![U256::MAX, U256::MAX]);
// Scalar multiplication #1 // Scalar multiplication #1
let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point4.1, point4.0])?); assert_eq!(stack, u256ify([point4.1, point4.0])?);
// Scalar multiplication #2 // Scalar multiplication #2
let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Scalar multiplication #3 // Scalar multiplication #3
let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point0.1, point0.0])?); assert_eq!(stack, u256ify([point0.1, point0.0])?);
// Scalar multiplication #4 // Scalar multiplication #4
let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?; let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Scalar multiplication #5 // Scalar multiplication #5
let initial_stack = u256ify(["0xdeadbeef", s, invalid.1, invalid.0])?; let initial_stack = u256ify(["0xdeadbeef", s, invalid.1, invalid.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX, U256::MAX]); assert_eq!(stack, vec![U256::MAX, U256::MAX]);
// Multiple calls // Multiple calls
@ -126,7 +126,7 @@ mod bn {
point0.1, point0.1,
point0.0, point0.0,
])?; ])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point4.1, point4.0])?); assert_eq!(stack, u256ify([point4.1, point4.0])?);
Ok(()) Ok(())
@ -176,55 +176,55 @@ mod secp {
// Standard addition #1 // Standard addition #1
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point1.1, point1.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point2.1, point2.0])?); assert_eq!(stack, u256ify([point2.1, point2.0])?);
// Standard addition #2 // Standard addition #2
let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point2.1, point2.0])?); assert_eq!(stack, u256ify([point2.1, point2.0])?);
// Standard doubling #1 // Standard doubling #1
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Standard doubling #2 // Standard doubling #2
let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_double, initial_stack).stack; let stack = run(&kernel.code, ec_double, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Standard doubling #3 // Standard doubling #3
let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x2", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point3.1, point3.0])?); assert_eq!(stack, u256ify([point3.1, point3.0])?);
// Addition with identity #1 // Addition with identity #1
let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?; let initial_stack = u256ify(["0xdeadbeef", identity.1, identity.0, point1.1, point1.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point1.1, point1.0])?); assert_eq!(stack, u256ify([point1.1, point1.0])?);
// Addition with identity #2 // Addition with identity #2
let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?; let initial_stack = u256ify(["0xdeadbeef", point1.1, point1.0, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point1.1, point1.0])?); assert_eq!(stack, u256ify([point1.1, point1.0])?);
// Addition with identity #3 // Addition with identity #3
let initial_stack = let initial_stack =
u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?; u256ify(["0xdeadbeef", identity.1, identity.0, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Scalar multiplication #1 // Scalar multiplication #1
let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", s, point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point4.1, point4.0])?); assert_eq!(stack, u256ify([point4.1, point4.0])?);
// Scalar multiplication #2 // Scalar multiplication #2
let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x0", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Scalar multiplication #3 // Scalar multiplication #3
let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?; let initial_stack = u256ify(["0xdeadbeef", "0x1", point0.1, point0.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([point0.1, point0.0])?); assert_eq!(stack, u256ify([point0.1, point0.0])?);
// Scalar multiplication #4 // Scalar multiplication #4
let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?; let initial_stack = u256ify(["0xdeadbeef", s, identity.1, identity.0])?;
let stack = run(&kernel.code, ec_mul, initial_stack).stack; let stack = run(&kernel.code, ec_mul, initial_stack)?.stack;
assert_eq!(stack, u256ify([identity.1, identity.0])?); assert_eq!(stack, u256ify([identity.1, identity.0])?);
// Multiple calls // Multiple calls
@ -238,7 +238,7 @@ mod secp {
point0.1, point0.1,
point0.0, point0.0,
])?; ])?;
let stack = run(&kernel.code, ec_add, initial_stack).stack; let stack = run(&kernel.code, ec_add, initial_stack)?.stack;
assert_eq!(stack, u256ify([point4.1, point4.0])?); assert_eq!(stack, u256ify([point4.1, point4.0])?);
Ok(()) Ok(())

4
evm/src/cpu/kernel/tests/ecrecover.rs
View File

@ -25,7 +25,7 @@ fn test_valid_ecrecover(
) -> Result<()> { ) -> Result<()> {
let ecrecover = kernel.global_labels["ecrecover"]; let ecrecover = kernel.global_labels["ecrecover"];
let initial_stack = u256ify([s, r, v, hash])?; let initial_stack = u256ify([s, r, v, hash])?;
let stack = run(&kernel.code, ecrecover, initial_stack).stack; let stack = run(&kernel.code, ecrecover, initial_stack)?.stack;
let got = pubkey_to_addr(stack[1], stack[0]); let got = pubkey_to_addr(stack[1], stack[0]);
assert_eq!(got, hex::decode(&expected[2..]).unwrap()); assert_eq!(got, hex::decode(&expected[2..]).unwrap());
@ -35,7 +35,7 @@ fn test_valid_ecrecover(
fn test_invalid_ecrecover(hash: &str, v: &str, r: &str, s: &str, kernel: &Kernel) -> Result<()> { fn test_invalid_ecrecover(hash: &str, v: &str, r: &str, s: &str, kernel: &Kernel) -> Result<()> {
let ecrecover = kernel.global_labels["ecrecover"]; let ecrecover = kernel.global_labels["ecrecover"];
let initial_stack = u256ify(["0xdeadbeef", s, r, v, hash])?; let initial_stack = u256ify(["0xdeadbeef", s, r, v, hash])?;
let stack = run(&kernel.code, ecrecover, initial_stack).stack; let stack = run(&kernel.code, ecrecover, initial_stack)?.stack;
assert_eq!(stack, vec![U256::MAX]); assert_eq!(stack, vec![U256::MAX]);
Ok(()) Ok(())

12
evm/src/cpu/kernel/tests/exp.rs
View File

@ -18,26 +18,26 @@ fn test_exp() -> Result<()> {
// Random input // Random input
let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, a]; let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, a];
let stack_with_kernel = run(&kernel.code, exp, initial_stack).stack; let stack_with_kernel = run(&kernel.code, exp, initial_stack)?.stack;
let initial_stack = vec![b, a]; let initial_stack = vec![b, a];
let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
let stack_with_opcode = run(&code, 0, initial_stack).stack; let stack_with_opcode = run(&code, 0, initial_stack)?.stack;
assert_eq!(stack_with_kernel, stack_with_opcode); assert_eq!(stack_with_kernel, stack_with_opcode);
// 0 base // 0 base
let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, U256::zero()]; let initial_stack = vec![U256::from_str("0xdeadbeef")?, b, U256::zero()];
let stack_with_kernel = run(&kernel.code, exp, initial_stack).stack; let stack_with_kernel = run(&kernel.code, exp, initial_stack)?.stack;
let initial_stack = vec![b, U256::zero()]; let initial_stack = vec![b, U256::zero()];
let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
let stack_with_opcode = run(&code, 0, initial_stack).stack; let stack_with_opcode = run(&code, 0, initial_stack)?.stack;
assert_eq!(stack_with_kernel, stack_with_opcode); assert_eq!(stack_with_kernel, stack_with_opcode);
// 0 exponent // 0 exponent
let initial_stack = vec![U256::from_str("0xdeadbeef")?, U256::zero(), a]; let initial_stack = vec![U256::from_str("0xdeadbeef")?, U256::zero(), a];
let stack_with_kernel = run(&kernel.code, exp, initial_stack).stack; let stack_with_kernel = run(&kernel.code, exp, initial_stack)?.stack;
let initial_stack = vec![U256::zero(), a]; let initial_stack = vec![U256::zero(), a];
let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP let code = [0xa, 0x63, 0xde, 0xad, 0xbe, 0xef, 0x56]; // EXP, PUSH4 deadbeef, JUMP
let stack_with_opcode = run(&code, 0, initial_stack).stack; let stack_with_opcode = run(&code, 0, initial_stack)?.stack;
assert_eq!(stack_with_kernel, stack_with_opcode); assert_eq!(stack_with_kernel, stack_with_opcode);
Ok(()) Ok(())