refactor extcodecopy, fix tests?

Author: rakita

crates/handler/src/validation.rs

@@ -437,21 +437,21 @@ mod tests {
 
     #[test]
     fn test_eip7907_code_size_limit_success() {
-        // EIP-7907: MAX_CODE_SIZE = 0x40000, but EIP-7825 txn gas limit cap is 30_000_000 so only ~0x0BFFF (49151 bytes)
-        // size contract can be used. Use the simplest method to return a contract code size equal to 0x0BFFF (49151 bytes)
-        // PUSH3 0x0BFFF - return size
+        // EIP-7907: MAX_CODE_SIZE = 0xc000, but EIP-7825 txn gas limit cap is 30_000_000 so only ~0x0c000 (49152 bytes)
+        // size contract can be used. Use the simplest method to return a contract code size equal to 0x0c000 (49152 bytes)
+        // PUSH3 0x0c000 - return size
         // PUSH1 0x00 - memory position 0
         // RETURN - return uninitialized memory, will be filled with 0
         let init_code: Vec<u8> = vec![
-            0x62, 0x00, 0xBF, 0xFF, // PUSH3 0x0BFFF
+            0x62, 0x00, 0xc0, 0x00, // PUSH3 0x0c000
             0x60, 0x00, // PUSH1 0
             0xf3, // RETURN
         ];
         let bytecode: Bytes = init_code.into();
         let r = deploy_contract(bytecode, Some(SpecId::OSAKA));
         assert!(matches!(r, Ok(ExecutionResult::Success { .. },)), "{r:?}");
         let gas_used = r.unwrap().gas_used();
-        assert!(gas_used > 29_000_000 && gas_used < 30_000_000);
+        assert_eq!(gas_used, 9892700);
     }
 
     /// EIP-7825: Transaction Gas Limit Cap in Osaka (at 30M gas) will effectively limit the code size
@@ -717,7 +717,7 @@ mod tests {
         // PUSH1 0x00      - the memory position
         // MSTORE          - store a non-zero value at the beginning of memory
 
-        // PUSH3 0x18001    - the return size (exceeds 0x18000)
+        // PUSH3 0x18000    - the return size (exceeds 0x18000)
         // PUSH1 0x00      - the memory offset
         // PUSH1 0x00      - the amount of ETH sent
         // CREATE          - create contract instruction (create contract from current memory)
@@ -734,7 +734,7 @@ mod tests {
             0x60, 0x00, // PUSH1 0x00
             0x52, // MSTORE
             // 2. prepare to create a large contract
-            0x62, 0x01, 0x80, 0x01, // PUSH3 0x18001 (exceeds 0x18000)
+            0x62, 0x01, 0x80, 0x00, // PUSH3 0x18000
             0x60, 0x00, // PUSH1 0x00 (the memory offset)
             0x60, 0x00, // PUSH1 0x00 (the amount of ETH sent)
             0xf0, // CREATE
@@ -816,7 +816,7 @@ mod tests {
             0x60, 0x00, // PUSH1 0x00
             0x52, // MSTORE
             // 2. prepare to create a contract
-            0x62, 0x04, 0x00, 0x00, // PUSH3 0x40000
+            0x62, 0x01, 0x80, 0x00, // PUSH3 0x18000
             0x60, 0x00, // PUSH1 0x00 (the memory offset)
             0x60, 0x00, // PUSH1 0x00 (the amount of ETH sent)
             0xf0, // CREATE

crates/interpreter/src/gas/calc.rs

@@ -112,24 +112,47 @@ pub const fn copy_cost_verylow(len: usize) -> Option<u64> {
     copy_cost(VERYLOW, len)
 }
 
-/// `EXTCODECOPY` opcode cost calculation.
+/// `EXTCODECOPY` opcode cost calculation, berlin specific.
 #[inline]
-pub const fn extcodecopy_cost(
+pub const fn berlin_extcodecopy_cost<T>(
+    spec_id: SpecId,
+    state_load: &StateCodeLoad<T>,
+    copy_len: usize,
+) -> Option<u64> {
+    extcodecopy_inner_cost(spec_id, state_load.is_cold, None, copy_len)
+}
+
+/// `EXTCODECOPY` opcode cost calculation, osaka specific.
+#[inline]
+pub const fn osaka_extcodecopy_cost(
     spec_id: SpecId,
     state_load: &StateCodeLoad<usize>,
     copy_len: usize,
+) -> Option<u64> {
+    extcodecopy_inner_cost(spec_id, state_load.is_cold, Some(state_load.data), copy_len)
+}
+
+/// `EXTCODECOPY` opcode cost calculation, common for berlin and osaka.
+#[inline]
+pub const fn extcodecopy_inner_cost(
+    spec_id: SpecId,
+    is_cold: bool,
+    is_code_cold_and_size: Option<usize>,
+    copy_len: usize,
 ) -> Option<u64> {
     let mut base_gas = if spec_id.is_enabled_in(SpecId::BERLIN) {
-        warm_cold_cost(state_load.is_cold)
+        warm_cold_cost(is_cold)
     } else if spec_id.is_enabled_in(SpecId::TANGERINE) {
         700
     } else {
         20
     };
 
-    if spec_id.is_enabled_in(SpecId::OSAKA) && state_load.is_code_cold {
-        // extra cost for large code size.
-        base_gas += large_contract_code_size_cost(state_load.data);
+    if spec_id.is_enabled_in(SpecId::OSAKA) {
+        if let Some(code_size) = is_code_cold_and_size {
+            // extra cost for large code size.
+            base_gas += large_contract_code_size_cost(code_size);
+        }
     }
     copy_cost(base_gas, copy_len)
 }

crates/interpreter/src/instructions/host.rs

@@ -61,14 +61,12 @@ pub fn selfbalance<WIRE: InterpreterTypes, H: Host + ?Sized>(
 ///
 /// Gets the size of an account's code.
 pub fn extcodesize<WIRE: InterpreterTypes, H: Host + ?Sized>(
-    context: InstructionContext<'_, H, WIRE>,
+    mut context: InstructionContext<'_, H, WIRE>,
 ) {
     popn_top!([], top, context.interpreter);
     let address = top.into_address();
     let Some(code_size) = context.host.load_account_code_size(address) else {
-        context
-            .interpreter
-            .halt(InstructionResult::FatalExternalError);
+        context.fatal_halt();
         return;
     };
 
@@ -128,21 +126,36 @@ pub fn extcodecopy<WIRE: InterpreterTypes, H: Host + ?Sized>(
         context.interpreter
     );
     let address = address.into_address();
+    let len = as_usize_or_fail!(context.interpreter, len_u256);
 
-    // load code size and check if it is cold.
-    let Some(code_size) = context.host.load_account_code_size(address) else {
-        return context.fatal_halt();
-    };
+    let spec_id = context.interpreter.runtime_flag.spec_id();
+    let code = if spec_id.is_enabled_in(OSAKA) {
+        // load code size and check if it is cold.
+        let Some(code_size) = context.host.load_account_code_size(address) else {
+            return context.fatal_halt();
+        };
 
-    let len = as_usize_or_fail!(context.interpreter, len_u256);
-    gas_or_fail!(
-        context.interpreter,
-        gas::extcodecopy_cost(context.interpreter.runtime_flag.spec_id(), &code_size, len)
-    );
+        gas_or_fail!(
+            context.interpreter,
+            gas::osaka_extcodecopy_cost(spec_id, &code_size, len)
+        );
+
+        // load code and make it warm.
+        let Some(code) = context.host.load_account_code(address) else {
+            return context.fatal_halt();
+        };
+        code.data
+    } else {
+        // load code.
+        let Some(code) = context.host.load_account_code(address) else {
+            return context.fatal_halt();
+        };
 
-    // load code and make it warm.
-    let Some(code) = context.host.load_account_code(address) else {
-        return context.fatal_halt();
+        gas_or_fail!(
+            context.interpreter,
+            gas::berlin_extcodecopy_cost(spec_id, &code, len)
+        );
+        code.data
     };
 
     // for len == 0 memory expansion is not done.