Breaking: rename "EVM interpreter" -> "EVM emulator"

crates/vm2/benches/nested_near_call.rs

@@ -36,7 +36,7 @@ fn nested_near_call(bencher: Bencher) {
             10_000_000,
             Settings {
                 default_aa_code_hash: [0; 32],
-                evm_interpreter_code_hash: [0; 32],
+                evm_emulator_code_hash: [0; 32],
                 hook_address: 0,
             },
         );
@@ -83,7 +83,7 @@ fn nested_near_call_with_storage_write(bencher: Bencher) {
             80_000_000,
             Settings {
                 default_aa_code_hash: [0; 32],
-                evm_interpreter_code_hash: [0; 32],
+                evm_emulator_code_hash: [0; 32],
                 hook_address: 0,
             },
         );

crates/vm2/src/callframe.rs

@@ -73,13 +73,13 @@ impl<T, W> Callframe<T, W> {
         exception_handler: u16,
         context_u128: u128,
         is_static: bool,
-        is_evm_interpreter: bool,
+        is_evm_emulator: bool,
         world_before_this_frame: Snapshot,
     ) -> Self {
         let is_kernel = is_kernel(address);
         let heap_size = if is_kernel {
             NEW_KERNEL_FRAME_MEMORY_STIPEND
-        } else if is_evm_interpreter {
+        } else if is_evm_emulator {
             NEW_EVM_FRAME_MEMORY_STIPEND
         } else {
             NEW_FRAME_MEMORY_STIPEND

crates/vm2/src/decommit.rs

@@ -13,7 +13,7 @@ impl WorldDiff {
         tracer: &mut T,
         address: U256,
         default_aa_code_hash: [u8; 32],
-        evm_interpreter_code_hash: [u8; 32],
+        evm_emulator_code_hash: [u8; 32],
         is_constructor_call: bool,
     ) -> Option<(UnpaidDecommit, bool)> {
         let deployer_system_contract_address =
@@ -63,7 +63,7 @@ impl WorldDiff {
                         try_default_aa?
                     } else {
                         is_evm = true;
-                        evm_interpreter_code_hash
+                        evm_emulator_code_hash
                     }
                 }
                 _ if code_info == U256::zero() => try_default_aa?,

crates/vm2/src/instruction_handlers/far_call.rs

@@ -65,7 +65,7 @@ where
                 tracer,
                 destination_address,
                 vm.settings.default_aa_code_hash,
-                vm.settings.evm_interpreter_code_hash,
+                vm.settings.evm_emulator_code_hash,
                 abi.is_constructor_call,
             );
 
@@ -104,7 +104,7 @@ where
         let new_frame_gas = normally_passed_gas + mandated_gas;
 
         // A far call pushes a new frame and returns from it in the next instruction if it panics.
-        let (calldata, program, is_evm_interpreter) =
+        let (calldata, program, is_evm_emulator) =
             fallible_part.unwrap_or_else(|| (U256::zero().into(), Program::new_panicking(), false));
 
         let new_frame_is_static = IS_STATIC || vm.state.current_frame.is_static;
@@ -113,8 +113,8 @@ where
             program,
             new_frame_gas,
             exception_handler,
-            new_frame_is_static && !is_evm_interpreter,
-            is_evm_interpreter,
+            new_frame_is_static && !is_evm_emulator,
+            is_evm_emulator,
             calldata.memory_page,
             vm.world_diff.snapshot(),
         );
@@ -134,8 +134,8 @@ where
         vm.state.register_pointer_flags = 2;
         vm.state.registers[1] = calldata.into_u256();
 
-        let is_static_call_to_evm_interpreter = new_frame_is_static && is_evm_interpreter;
-        let call_type = (u8::from(is_static_call_to_evm_interpreter) << 2)
+        let is_static_call_to_evm_emulator = new_frame_is_static && is_evm_emulator;
+        let call_type = (u8::from(is_static_call_to_evm_emulator) << 2)
             | (u8::from(abi.is_system_call) << 1)
             | u8::from(abi.is_constructor_call);
 

crates/vm2/src/single_instruction_test/into_zk_evm.rs

@@ -39,7 +39,7 @@ pub fn vm2_to_zk_evm<T: Tracer, W: World<T>>(
         local_state: vm2_state_to_zk_evm_state(&vm.state),
         block_properties: BlockProperties {
             default_aa_code_hash: U256::from_big_endian(&vm.settings.default_aa_code_hash),
-            evm_simulator_code_hash: U256::from_big_endian(&vm.settings.evm_interpreter_code_hash),
+            evm_simulator_code_hash: U256::from_big_endian(&vm.settings.evm_emulator_code_hash),
             zkporter_is_available: false,
         },
         storage: MockWorldWrapper(world),

crates/vm2/src/single_instruction_test/vm.rs

@@ -123,13 +123,13 @@ impl<'a> Arbitrary<'a> for Settings {
         default_aa_code_hash[0] = 1;
         u.fill_buffer(&mut default_aa_code_hash[2..])?;
 
-        let mut evm_interpreter_code_hash = [0u8; 32];
-        evm_interpreter_code_hash[0] = 1;
-        u.fill_buffer(&mut evm_interpreter_code_hash[2..])?;
+        let mut evm_emulator_code_hash = [0u8; 32];
+        evm_emulator_code_hash[0] = 1;
+        u.fill_buffer(&mut evm_emulator_code_hash[2..])?;
 
         Ok(Self {
             default_aa_code_hash,
-            evm_interpreter_code_hash,
+            evm_emulator_code_hash,
             hook_address: 0, // Doesn't matter; we don't decode in bootloader mode
         })
     }

crates/vm2/src/tests/bytecode_behaviour.rs

@@ -25,7 +25,7 @@ fn call_to_invalid_address() {
         10000,
         Settings {
             default_aa_code_hash: [0; 32],
-            evm_interpreter_code_hash: [0; 32],
+            evm_emulator_code_hash: [0; 32],
             hook_address: 0,
         },
     );

crates/vm2/src/tests/far_call_decommitment.rs

@@ -124,7 +124,7 @@ fn test() {
         initial_gas,
         Settings {
             default_aa_code_hash: [0; 32],
-            evm_interpreter_code_hash: [0; 32],
+            evm_emulator_code_hash: [0; 32],
             hook_address: 0,
         },
     );
@@ -160,7 +160,7 @@ fn test_with_initial_out_of_gas_error() {
         10_000,
         Settings {
             default_aa_code_hash: [0; 32],
-            evm_interpreter_code_hash: [0; 32],
+            evm_emulator_code_hash: [0; 32],
             hook_address: 0,
         },
     );

crates/vm2/src/tests/panic.rs

@@ -41,7 +41,7 @@ proptest! {
             1000,
             Settings {
                 default_aa_code_hash: [0; 32],
-                evm_interpreter_code_hash: [0; 32],
+                evm_emulator_code_hash: [0; 32],
                 hook_address: 0,
             },
         );

crates/vm2/src/tests/trace_failing_far_call.rs

@@ -81,7 +81,7 @@ fn trace_failing_far_call() {
         1000,
         Settings {
             default_aa_code_hash: [0; 32],
-            evm_interpreter_code_hash: [0; 32],
+            evm_emulator_code_hash: [0; 32],
             hook_address: 0,
         },
     );

crates/vm2/src/tracing.rs

@@ -458,7 +458,7 @@ mod test {
             1000,
             crate::Settings {
                 default_aa_code_hash: [0; 32],
-                evm_interpreter_code_hash: [0; 32],
+                evm_emulator_code_hash: [0; 32],
                 hook_address: 0,
             },
         );

crates/vm2/src/vm.rs

@@ -18,8 +18,8 @@ use crate::{
 pub struct Settings {
     /// Bytecode hash of the default account abstraction contract.
     pub default_aa_code_hash: [u8; 32],
-    /// Bytecode hash of the EVM interpreter.
-    pub evm_interpreter_code_hash: [u8; 32],
+    /// Bytecode hash of the EVM emulator.
+    pub evm_emulator_code_hash: [u8; 32],
     /// Writing to this address in the bootloader's heap suspends execution
     pub hook_address: u32,
 }
@@ -199,7 +199,7 @@ impl<T: Tracer, W> VirtualMachine<T, W> {
         gas: u32,
         exception_handler: u16,
         is_static: bool,
-        is_evm_interpreter: bool,
+        is_evm_emulator: bool,
         calldata_heap: HeapId,
         world_before_this_frame: Snapshot,
     ) {
@@ -228,7 +228,7 @@ impl<T: Tracer, W> VirtualMachine<T, W> {
                 self.state.context_u128
             },
             is_static,
-            is_evm_interpreter,
+            is_evm_emulator,
             world_before_this_frame,
         );
         self.state.context_u128 = 0;