Add bytecode hash in interpreter #1888

crates/interpreter/src/interpreter.rs

@@ -59,6 +59,7 @@ impl<EXT: Default, MG: MemoryGetter> Interpreter<EthInterpreter<EXT, MG>> {
             is_eof: bytecode.is_eof(),
             is_eof_init,
         };
+
         Self {
             bytecode: ExtBytecode::new(bytecode),
             stack: Stack::new(),
@@ -289,8 +290,6 @@ mod tests {
     use super::*;
     use bytecode::Bytecode;
     use primitives::{Address, Bytes, U256};
-    use specification::hardfork::SpecId;
-    use std::{cell::RefCell, rc::Rc};
 
     #[test]
     #[cfg(feature = "serde")]

crates/interpreter/src/interpreter/ext_bytecode.rs

@@ -3,7 +3,7 @@ use bytecode::{
     utils::{read_i16, read_u16},
     Bytecode,
 };
-use primitives::Bytes;
+use primitives::{Bytes, B256};
 
 use super::{EofCodeInfo, EofContainer, EofData, Immediates, Jumps, LegacyBytecode};
 
@@ -13,6 +13,7 @@ mod serde;
 #[derive(Debug)]
 pub struct ExtBytecode {
     base: Bytecode,
+    bytecode_hash: Option<B256>,
     instruction_pointer: *const u8,
 }
 
@@ -29,6 +30,27 @@ impl ExtBytecode {
         Self {
             base,
             instruction_pointer,
+            bytecode_hash: None,
+        }
+    }
+
+    /// Creates new `ExtBytecode` with the given hash.
+    pub fn new_with_hash(base: Bytecode, hash: B256) -> Self {
+        let instruction_pointer = base.bytecode().as_ptr();
+        Self {
+            base,
+            instruction_pointer,
+            bytecode_hash: Some(hash),
+        }
+    }
+
+    pub fn hash(&mut self) -> B256 {
+        if let Some(hash) = self.bytecode_hash {
+            hash
+        } else {
+            let hash = self.base.hash_slow();
+            self.bytecode_hash = Some(hash);
+            hash
         }
     }
 }
@@ -164,3 +186,28 @@ impl LegacyBytecode for ExtBytecode {
         self.base.original_byte_slice()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use primitives::Bytes;
+
+    #[test]
+    fn test_hash_caching() {
+        let bytecode = Bytecode::new_raw(Bytes::new());
+        let mut ext_bytecode = ExtBytecode::new(bytecode.clone());
+        assert_eq!(ext_bytecode.bytecode_hash, None);
+
+        let hash = ext_bytecode.hash();
+        assert_eq!(hash, bytecode.hash_slow());
+        assert_eq!(ext_bytecode.bytecode_hash, Some(bytecode.hash_slow()));
+    }
+
+    #[test]
+    fn test_with_hash_constructor() {
+        let bytecode = Bytecode::new_raw(Bytes::from(&[0x60, 0x00][..]));
+        let hash = bytecode.hash_slow();
+        let ext_bytecode = ExtBytecode::new_with_hash(bytecode.clone(), hash);
+        assert_eq!(ext_bytecode.bytecode_hash, Some(hash));
+    }
+}

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

@@ -1,11 +1,13 @@
 use super::ExtBytecode;
 use crate::interpreter::Jumps;
+use primitives::B256;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[derive(Serialize, Deserialize)]
 struct ExtBytecodeSerde {
     base: bytecode::Bytecode,
     program_counter: usize,
+    bytecode_hash: Option<B256>,
 }
 
 impl Serialize for ExtBytecode {
@@ -16,6 +18,7 @@ impl Serialize for ExtBytecode {
         ExtBytecodeSerde {
             base: self.base.clone(),
             program_counter: self.pc(),
+            bytecode_hash: self.bytecode_hash,
         }
         .serialize(serializer)
     }
@@ -29,9 +32,14 @@ impl<'de> Deserialize<'de> for ExtBytecode {
         let ExtBytecodeSerde {
             base,
             program_counter,
+            bytecode_hash,
         } = ExtBytecodeSerde::deserialize(deserializer)?;
 
-        let mut bytecode = Self::new(base);
+        let mut bytecode = if let Some(hash) = bytecode_hash {
+            Self::new_with_hash(base, hash)
+        } else {
+            Self::new(base)
+        };
 
         if program_counter >= bytecode.base.bytecode().len() {
             panic!("serde pc: {program_counter} is greater than or equal to bytecode len");