feat(EOF): add evmone test suite

.github/workflows/ethereum-tests.yml

@@ -48,10 +48,12 @@ jobs:
             ethtests/EIPTests/StateTests/stEIP1153-transientStorage/ \
             ethtests/EIPTests/StateTests/stEIP4844-blobtransactions/ \
             ethtests/EIPTests/StateTests/stEIP2537/ \
-            tests/eof_suite/state_tests \
+            tests/eof_suite/eest/state_tests \
+            tests/eof_suite/evmone/state_tests \
             tests/prague_suite/state_tests
       - name: Run EOF validation tests
         run: |
           cross run --target ${{matrix.target}} --profile ${{ matrix.profile }} -p revme -- eof-validation \
-          tests/eof_suite/eof_tests/prague
+          tests/eof_suite/eest/eof_tests/prague \
+          tests/eof_suite/evmone/eof_tests
 

bins/revme/src/cmd/eofvalidation.rs

@@ -13,17 +13,20 @@ use structopt::StructOpt;
 pub struct Cmd {
     /// Input path to eof validation test
     #[structopt(required = true)]
-    path: PathBuf,
+    path: Vec<PathBuf>,
 }
 
 impl Cmd {
     /// Run statetest command.
     pub fn run(&self) -> Result<(), Error> {
         // check if path exists.
-        if !self.path.exists() {
-            return Err(Error::Custom("The specified path does not exist"));
+        for path in &self.path {
+            if !path.exists() {
+                return Err(Error::Custom("The specified path does not exist"));
+            }
+            run_test(path)?
         }
-        run_test(&self.path)
+        Ok(())
     }
 }
 
@@ -47,7 +50,7 @@ pub fn run_test(path: &Path) -> Result<(), Error> {
                 let kind = if test_vector.container_kind.is_some() {
                     Some(CodeType::ReturnContract)
                 } else {
-                    None
+                    Some(CodeType::ReturnOrStop)
                 };
                 let res = validate_raw_eof_inner(test_vector.code.clone(), kind);
                 if res.is_ok() != test_vector.results.prague.result {

bins/revme/src/cmd/eofvalidation/test_suite.rs

@@ -10,6 +10,7 @@ pub struct TestSuite(pub BTreeMap<String, TestUnit>);
 pub struct TestUnit {
     #[serde(default, rename = "_info")]
     pub info: Option<serde_json::Value>,
+    #[serde(default)]
     pub vectors: BTreeMap<String, TestVector>,
 }
 

bins/revme/src/cmd/statetest/models/mod.rs

@@ -91,6 +91,7 @@ pub struct AccountInfo {
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 pub struct Env {
     pub current_coinbase: Address,
+    #[serde(default)]
     pub current_difficulty: U256,
     pub current_gas_limit: U256,
     pub current_number: U256,
@@ -118,7 +119,7 @@ pub struct TransactionParts {
     /// if sender is not present we need to derive it from secret key.
     #[serde(default)]
     pub sender: Option<Address>,
-    #[serde(deserialize_with = "deserialize_maybe_empty")]
+    #[serde(default, deserialize_with = "deserialize_maybe_empty")]
     pub to: Option<Address>,
     pub value: Vec<U256>,
     pub max_fee_per_gas: Option<U256>,

bins/revme/src/cmd/statetest/models/spec.rs

@@ -26,6 +26,7 @@ pub enum SpecName {
     Cancun,
     Prague,
     PragueEOF,
+    Osaka, // SKIPPED
     #[serde(other)]
     Unknown,
 }
@@ -52,6 +53,7 @@ impl SpecName {
             Self::ByzantiumToConstantinopleAt5 | Self::Constantinople => {
                 panic!("Overridden with PETERSBURG")
             }
+            Self::Osaka => panic!("Osaka is not implemented"),
             Self::Unknown => panic!("Unknown spec"),
         }
     }

bins/revme/src/cmd/statetest/runner.rs

@@ -124,6 +124,15 @@ fn skip_test(path: &Path) -> bool {
         | "static_Call50000_sha256.json"
         | "loopMul.json"
         | "CALLBlake2f_MaxRounds.json"
+
+        // evmone statetest
+        | "initcode_transaction_before_prague.json"
+        | "invalid_tx_non_existing_sender.json"
+        | "tx_non_existing_sender.json"
+        | "block_apply_withdrawal.json"
+        | "block_apply_ommers_reward.json"
+        | "known_block_hash.json"
+        | "eip7516_blob_base_fee.json"
     ) || path_str.contains("stEOF")
 }
 
@@ -322,12 +331,17 @@ pub fn execute_test_suite(
             // Constantinople was immediately extended by Petersburg.
             // There isn't any production Constantinople transaction
             // so we don't support it and skip right to Petersburg.
-            if spec_name == SpecName::Constantinople {
+            if spec_name == SpecName::Constantinople || spec_name == SpecName::Osaka {
                 continue;
             }
 
             let spec_id = spec_name.to_spec_id();
 
+            if spec_id.is_enabled_in(SpecId::MERGE) && env.block.prevrandao.is_none() {
+                // if spec is merge and prevrandao is not set, set it to default
+                env.block.prevrandao = Some(B256::default());
+            }
+
             for (index, test) in tests.into_iter().enumerate() {
                 env.tx.gas_limit = unit.transaction.gas_limit[test.indexes.gas].saturating_to();
 

crates/interpreter/src/instruction_result.rs

@@ -134,6 +134,7 @@ impl From<HaltReason> for InstructionResult {
             HaltReason::EofAuxDataOverflow => Self::EofAuxDataOverflow,
             HaltReason::EofAuxDataTooSmall => Self::EofAuxDataTooSmall,
             HaltReason::EOFFunctionStackOverflow => Self::EOFFunctionStackOverflow,
+            HaltReason::InvalidEXTCALLTarget => Self::InvalidEXTCALLTarget,
             #[cfg(feature = "optimism")]
             HaltReason::FailedDeposit => Self::FatalExternalError,
         }
@@ -226,8 +227,6 @@ pub enum InternalResult {
     InternalCallOrCreate,
     /// Internal CREATE/CREATE starts with 0xEF00
     CreateInitCodeStartingEF00,
-    /// Check for target address validity is only done inside subcall.
-    InvalidEXTCALLTarget,
     /// Internal to ExtDelegateCall
     InvalidExtDelegateCallTarget,
 }
@@ -338,9 +337,7 @@ impl From<InstructionResult> for SuccessOrHalt {
             InstructionResult::ReturnContract => Self::Success(SuccessReason::EofReturnContract),
             InstructionResult::EofAuxDataOverflow => Self::Halt(HaltReason::EofAuxDataOverflow),
             InstructionResult::EofAuxDataTooSmall => Self::Halt(HaltReason::EofAuxDataTooSmall),
-            InstructionResult::InvalidEXTCALLTarget => {
-                Self::Internal(InternalResult::InvalidEXTCALLTarget)
-            }
+            InstructionResult::InvalidEXTCALLTarget => Self::Halt(HaltReason::InvalidEXTCALLTarget),
             InstructionResult::InvalidExtDelegateCallTarget => {
                 Self::Internal(InternalResult::InvalidExtDelegateCallTarget)
             }

crates/primitives/src/result.rs

@@ -467,6 +467,8 @@ pub enum HaltReason {
     EofAuxDataTooSmall,
     /// EOF Subroutine stack overflow
     EOFFunctionStackOverflow,
+    /// Check for target address validity is only done inside subcall.
+    InvalidEXTCALLTarget,
 
     /* Optimism errors */
     #[cfg(feature = "optimism")]

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_callf_truncated.json

@@ -0,0 +1,24 @@
+{
+  "EOF1_callf_truncated": {
+    "vectors": {
+      "EOF1_callf_truncated_0": {
+        "code": "0xef000101000402000100010400000000800000e3",
+        "results": {
+          "Prague": {
+            "exception": "EOF_TruncatedImmediate",
+            "result": false
+          }
+        }
+      },
+      "EOF1_callf_truncated_1": {
+        "code": "0xef000101000402000100020400000000800000e300",
+        "results": {
+          "Prague": {
+            "exception": "EOF_TruncatedImmediate",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_code_section_0_size.json

@@ -0,0 +1,24 @@
+{
+  "EOF1_code_section_0_size": {
+    "vectors": {
+      "EOF1_code_section_0_size_0": {
+        "code": "0xef000101000402000000",
+        "results": {
+          "Prague": {
+            "exception": "EOF_ZeroSectionSize",
+            "result": false
+          }
+        }
+      },
+      "EOF1_code_section_0_size_1": {
+        "code": "0xef000101000402000004000100da",
+        "results": {
+          "Prague": {
+            "exception": "EOF_ZeroSectionSize",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_code_section_missing.json

@@ -0,0 +1,24 @@
+{
+  "EOF1_code_section_missing": {
+    "vectors": {
+      "EOF1_code_section_missing_0": {
+        "code": "0xef000101000400",
+        "results": {
+          "Prague": {
+            "exception": "EOF_CodeSectionMissing",
+            "result": false
+          }
+        }
+      },
+      "EOF1_code_section_missing_1": {
+        "code": "0xef00010100040400010000800000da",
+        "results": {
+          "Prague": {
+            "exception": "EOF_CodeSectionMissing",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_code_section_offset.json

@@ -0,0 +1,14 @@
+{
+  "EOF1_code_section_offset": {
+    "vectors": {
+      "EOF1_code_section_offset_0": {
+        "code": "0xef000101000802000200030001040004000080000000800000e50001fe00000000",
+        "results": {
+          "Prague": {
+            "result": true
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_data_section_0_size.json

@@ -0,0 +1,14 @@
+{
+  "EOF1_data_section_0_size": {
+    "vectors": {
+      "EOF1_data_section_0_size_0": {
+        "code": "0xef000101000402000100010400000000800000fe",
+        "results": {
+          "Prague": {
+            "result": true
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_data_section_before_code_section.json

@@ -0,0 +1,15 @@
+{
+  "EOF1_data_section_before_code_section": {
+    "vectors": {
+      "EOF1_data_section_before_code_section_0": {
+        "code": "0xef000101000403000102000100010000800000aafe",
+        "results": {
+          "Prague": {
+            "exception": "EOF_CodeSectionMissing",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_data_section_before_types_section.json

@@ -0,0 +1,15 @@
+{
+  "EOF1_data_section_before_types_section": {
+    "vectors": {
+      "EOF1_data_section_before_types_section_0": {
+        "code": "0xef0001040001010004020001000100aa00800000fe",
+        "results": {
+          "Prague": {
+            "exception": "EOF_TypeSectionMissing",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}

tests/eof_suite/evmone/eof_tests/eof_validation/EOF1_dataloadn_truncated.json

@@ -0,0 +1,24 @@
+{
+  "EOF1_dataloadn_truncated": {
+    "vectors": {
+      "EOF1_dataloadn_truncated_0": {
+        "code": "0xef000101000402000100010400000000800000d1",
+        "results": {
+          "Prague": {
+            "exception": "EOF_TruncatedImmediate",
+            "result": false
+          }
+        }
+      },
+      "EOF1_dataloadn_truncated_1": {
+        "code": "0xef000101000402000100020400000000800000d100",
+        "results": {
+          "Prague": {
+            "exception": "EOF_TruncatedImmediate",
+            "result": false
+          }
+        }
+      }
+    }
+  }
+}