Prague precompiles refactoring

Author: mrLSD

Cargo.toml

@@ -25,4 +25,5 @@ sha3 = { version = "0.10", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 
 [patch.crates-io]
+# Constrain to v0.14.6 to ensure compatibility with sha3 0.10 and prevent unexpected upgrades
 generic-array = { git = "https://github.com/fizyk20/generic-array", rev = "effb209dd7e61b8226e194dec2979314e27598d1" }

evm-tests/jsontests/src/assertions.rs

@@ -4,7 +4,7 @@ use crate::config::TestConfig;
 use crate::types::Spec;
 use crate::types::{InvalidTxReason, PostState};
 
-/// Assert vicinity validation to ensure that test hos expected validation error
+/// Assert vicinity validation to ensure that test expected validation error
 #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
 pub fn assert_vicinity_validation(
     reason: &InvalidTxReason,
@@ -16,7 +16,7 @@ pub fn assert_vicinity_validation(
     let file_name = &test_config.file_name;
     match *spec {
         Spec::Istanbul | Spec::Berlin => match reason {
-            InvalidTxReason::GasPriseEip1559 => {
+            InvalidTxReason::GasPriceEip1559 => {
                 for (i, state) in states.iter().enumerate() {
                     let expected = state.expect_exception.as_deref().unwrap_or_else(|| {
                         panic!(
@@ -175,7 +175,7 @@ pub fn assert_vicinity_validation(
             InvalidTxReason::GasPriceLessThenBlockBaseFee => {
                 for (i, state) in states.iter().enumerate() {
                     let expected = state.expect_exception.as_deref().unwrap_or_else(|| {
-                        panic!("expected error message for test: {reason:?} [{spec:?}] {name}:{i})\n{file_name:?}")
+                        panic!("expected error message for test: {reason:?} [{spec:?}] {name}:{i}\n{file_name:?}")
                     });
                     let is_checked = expected == "TR_FeeCapLessThanBlocks"
                         || expected == "TransactionException.INSUFFICIENT_MAX_FEE_PER_GAS";

evm-tests/jsontests/src/main.rs

@@ -20,11 +20,8 @@ pub mod vm;
 mod assertions;
 mod config;
 mod execution_results;
-// TODO
-// mod old_precompiles;
 mod precompiles;
 mod state_dump;
-// mod utils;
 
 #[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
 fn main() -> Result<(), String> {

evm-tests/jsontests/src/precompiles.rs

@@ -3,6 +3,9 @@ mod kzg;
 use crate::precompiles::kzg::Kzg;
 use crate::types::Spec;
 use aurora_engine_modexp::AuroraModExp;
+use aurora_engine_precompiles::bls12_381::{
+    BlsG1Add, BlsG1Msm, BlsG2Add, BlsG2Msm, BlsMapFp2ToG2, BlsMapFpToG1, BlsPairingCheck,
+};
 use aurora_engine_precompiles::{
     alt_bn256::{Bn256Add, Bn256Mul, Bn256Pair},
     blake2::Blake2F,
@@ -118,7 +121,14 @@ impl Precompiles {
     }
 
     pub fn new_prague() -> Self {
-        let map = Self::new_cancun().0;
+        let mut map = Self::new_cancun().0;
+        map.insert(BlsG1Add::ADDRESS.raw(), Box::new(BlsG1Add));
+        map.insert(BlsG1Msm::ADDRESS.raw(), Box::new(BlsG1Msm));
+        map.insert(BlsG2Add::ADDRESS.raw(), Box::new(BlsG2Add));
+        map.insert(BlsG2Msm::ADDRESS.raw(), Box::new(BlsG2Msm));
+        map.insert(BlsPairingCheck::ADDRESS.raw(), Box::new(BlsPairingCheck));
+        map.insert(BlsMapFpToG1::ADDRESS.raw(), Box::new(BlsMapFpToG1));
+        map.insert(BlsMapFp2ToG2::ADDRESS.raw(), Box::new(BlsMapFp2ToG2));
         Self(map)
     }
 }

evm-tests/jsontests/src/precompiles/kzg.rs

@@ -1,6 +1,8 @@
 #![allow(clippy::module_inception, clippy::large_stack_arrays)]
 
-use aurora_engine_precompiles::{Context, EthGas, ExitError, Precompile, PrecompileOutput};
+use aurora_engine_precompiles::{
+    Context, EthGas, EvmPrecompileResult, ExitError, Precompile, PrecompileOutput,
+};
 use primitive_types::H160;
 use std::borrow::Cow::Borrowed;
 
@@ -271,7 +273,7 @@ impl Precompile for Kzg {
         target_gas: Option<EthGas>,
         _context: &Context,
         _is_static: bool,
-    ) -> Result<PrecompileOutput, ExitError> {
+    ) -> EvmPrecompileResult {
         let cost = Self::required_gas(input)?;
         if let Some(target_gas) = target_gas {
             if cost > target_gas {

evm-tests/jsontests/src/state.rs

@@ -4,7 +4,6 @@ use crate::assertions::{
 };
 use crate::config::TestConfig;
 use crate::execution_results::{FailedTestDetails, TestExecutionResult};
-// TODO: use crate::old_precompiles::JsonPrecompile;
 use crate::precompiles::Precompiles;
 use crate::state_dump::{StateTestsDump, StateTestsDumper};
 use crate::types::account_state::MemoryAccountsState;
@@ -48,17 +47,6 @@ pub fn test(test_config: TestConfig, test: StateTestCase) -> TestExecutionResult
 fn test_run(test_config: &TestConfig, test: &StateTestCase) -> TestExecutionResult {
     let mut tests_result = TestExecutionResult::new();
     for (spec, states) in &test.post_states {
-        // TODO
-        if *spec >= Spec::Prague {
-            continue;
-        }
-
-        // TODO
-        // if test_config.name != "tests/static/state_tests/stStaticCall/static_callBasicFiller.json::static_callBasic[fork_Prague-state_test-d1-g0-v0]" {
-        //     continue
-        // }
-        // println!("{test:?}");
-
         // Run tests for specific EVM hard fork (Spec)
         if let Some(s) = test_config.spec.as_ref() {
             if s != spec {
@@ -126,8 +114,6 @@ fn test_run(test_config: &TestConfig, test: &StateTestCase) -> TestExecutionResu
 
         for (i, state) in states.iter().enumerate() {
             let mut backend = MemoryBackend::new(&vicinity, original_state.0.clone());
-            // TODO
-            // println!("\nSTATE BEFORE: {:#?}", backend.state());
             tests_result.total += 1;
 
             // Test case may be expected to fail with an unsupported tx type if the current fork is
@@ -214,8 +200,6 @@ fn test_run(test_config: &TestConfig, test: &StateTestCase) -> TestExecutionResu
                         access_list.clone(),
                         authorization_list.clone(),
                     );
-                    // TODO
-                    // println!("\nCALLER: {caller:?}\nTO: {to:?}\nVALUE: {value:?}n{gas_limit:?}\n{:?}\n{:?}\nREASON: {_reason:?}",access_list,authorization_list);
                     assert_call_exit_exception(state.expect_exception.as_ref(), &test_config.name);
                 } else {
                     let code = data;
@@ -292,8 +276,6 @@ fn test_run(test_config: &TestConfig, test: &StateTestCase) -> TestExecutionResu
                 });
             }
 
-            // TODO
-            // println!("\nSTATE AFTER: {:#?}", backend.state());
             let backend_state = MemoryAccountsState(backend.state().clone());
             let (is_valid_hash, actual_hash) = backend_state.check_valid_hash(&state.hash);
             if !is_valid_hash {

evm-tests/jsontests/src/state_dump.rs

@@ -1,10 +1,9 @@
-// TODO: fix it
-#![allow(dead_code)]
 use crate::types::Spec;
 use aurora_evm::backend::{MemoryAccount, MemoryVicinity};
 use primitive_types::{H160, H256, U256};
 use std::collections::BTreeMap;
 
+#[allow(dead_code)]
 #[derive(Default, Debug, Clone)]
 #[cfg_attr(feature = "dump-state", derive(serde::Serialize, serde::Deserialize))]
 pub struct StateTestsDump {

evm-tests/jsontests/src/types/mod.rs

@@ -75,7 +75,7 @@ impl StateTestCase {
             tx.gas_price.or(tx.max_fee_per_gas).unwrap_or_default()
         } else {
             if tx.max_fee_per_gas.is_some() {
-                return Err(InvalidTxReason::GasPriseEip1559);
+                return Err(InvalidTxReason::GasPriceEip1559);
             }
             tx.gas_price.expect("expect gas price")
         };
@@ -267,7 +267,7 @@ pub enum InvalidTxReason {
     BlobGasPriceGreaterThanMax,
     BlobVersionedHashesNotSupported,
     MaxFeePerBlobGasNotSupported,
-    GasPriseEip1559,
+    GasPriceEip1559,
     AuthorizationListNotExist,
     AuthorizationListNotSupported,
     InvalidAuthorizationChain,

evm-tests/jsontests/src/utils.rs

@@ -355,8 +355,6 @@ pub mod transaction {
     use ethjson::uint::Uint;
     use primitive_types::{H160, H256, U256};
 
-    // TODO: it will be refactored as old solution inefficient, also will be removed clippy-allow flag
-    #[allow(clippy::too_many_arguments, clippy::too_many_lines)]
     pub fn validate(
         tx: &Transaction,
         block_gas_limit: U256,
@@ -557,7 +555,7 @@ pub mod transaction {
         BlobGasPriceGreaterThanMax,
         BlobVersionedHashesNotSupported,
         MaxFeePerBlobGasNotSupported,
-        GasPriseEip1559,
+        GasPriceEip1559,
         AuthorizationListNotExist,
         AuthorizationListNotSupported,
         InvalidAuthorizationChain,