implement serde for interpreter (#1909)

* implement serde for interpreter

* add bytecode check

* remove bytecode check

* remove defaults generic params

* add sanity check + cargo fmt

* modify panic message

crates/interpreter/src/interpreter.rs

@@ -29,6 +29,7 @@ use std::rc::Rc;
 use subroutine_stack::SubRoutineImpl;
 
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
 pub struct Interpreter<WIRE: InterpreterTypes> {
     pub bytecode: WIRE::Bytecode,
     pub stack: WIRE::Stack,
@@ -284,4 +285,40 @@ mod tests {
     //         >();
     //     let _ = interp.run(EMPTY_SHARED_MEMORY, table, host);
     // }
+
+    use super::*;
+    use bytecode::Bytecode;
+    use primitives::{Address, Bytes, U256};
+    use specification::hardfork::SpecId;
+    use std::{cell::RefCell, rc::Rc};
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_interpreter_serde() {
+        let bytecode = Bytecode::new_raw(Bytes::from(&[0x60, 0x00, 0x60, 0x00, 0x01][..]));
+        let interpreter = Interpreter::<EthInterpreter>::new(
+            Rc::new(RefCell::new(SharedMemory::new())),
+            bytecode,
+            InputsImpl {
+                target_address: Address::ZERO,
+                caller_address: Address::ZERO,
+                input: Bytes::default(),
+                call_value: U256::ZERO,
+            },
+            false,
+            false,
+            SpecId::LATEST,
+            u64::MAX,
+        );
+
+        let serialized = bincode::serialize(&interpreter).unwrap();
+
+        let deserialized: Interpreter<EthInterpreter> = bincode::deserialize(&serialized).unwrap();
+
+        assert_eq!(
+            interpreter.bytecode.pc(),
+            deserialized.bytecode.pc(),
+            "Program counter should be preserved"
+        );
+    }
 }

crates/interpreter/src/interpreter/ext_bytecode.rs

@@ -7,6 +7,9 @@ use primitives::Bytes;
 
 use super::{EofCodeInfo, EofContainer, EofData, Immediates, Jumps, LegacyBytecode};
 
+#[cfg(feature = "serde")]
+mod serde;
+
 #[derive(Debug)]
 pub struct ExtBytecode {
     base: Bytecode,

crates/interpreter/src/interpreter/ext_bytecode/serde.rs

@@ -0,0 +1,42 @@
+use super::ExtBytecode;
+use crate::interpreter::Jumps;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[derive(Serialize, Deserialize)]
+struct ExtBytecodeSerde {
+    base: bytecode::Bytecode,
+    program_counter: usize,
+}
+
+impl Serialize for ExtBytecode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        ExtBytecodeSerde {
+            base: self.base.clone(),
+            program_counter: self.pc(),
+        }
+        .serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for ExtBytecode {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let ExtBytecodeSerde {
+            base,
+            program_counter,
+        } = ExtBytecodeSerde::deserialize(deserializer)?;
+
+        let mut bytecode = Self::new(base);
+
+        if program_counter >= bytecode.base.bytecode().len() {
+            panic!("serde pc: {program_counter} is greater than or equal to bytecode len");
+        }
+        bytecode.absolute_jump(program_counter);
+        Ok(bytecode)
+    }
+}

crates/interpreter/src/interpreter/input.rs

@@ -1,6 +1,9 @@
 use crate::interpreter_types::InputsTrait;
 use primitives::{Address, Bytes, U256};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct InputsImpl {
     pub target_address: Address,
     pub caller_address: Address,

crates/interpreter/src/interpreter/loop_control.rs

@@ -1,6 +1,9 @@
 use crate::interpreter_types::LoopControl as LoopControlTrait;
 use crate::{Gas, InstructionResult, InterpreterAction};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LoopControl {
     /// The execution control flag. If this is not set to `Continue`, the interpreter will stop
     /// execution.

crates/interpreter/src/interpreter/return_data.rs

@@ -1,6 +1,9 @@
 use crate::interpreter::ReturnData;
 use primitives::Bytes;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Default)]
 pub struct ReturnDataImpl(Bytes);
 

crates/interpreter/src/interpreter/runtime_flags.rs

@@ -1,7 +1,10 @@
 use specification::hardfork::SpecId;
 
 use super::RuntimeFlag;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct RuntimeFlags {
     pub is_static: bool,
     pub is_eof_init: bool,