Refactore tests

engine-tests/src/tests/erc20.rs

@@ -12,8 +12,9 @@ use aurora_engine_types::account_id::AccountId;
 use aurora_engine_types::parameters::connector::{
     Erc20Identifier, Erc20Metadata, SetErc20MetadataArgs,
 };
-use aurora_engine_types::parameters::engine::SetOwnerArgs;
+use aurora_engine_types::parameters::engine::{SetOwnerArgs, TransactionStatusEvmErrorKind};
 use bstr::ByteSlice;
+
 use libsecp256k1::SecretKey;
 use std::str::FromStr;
 
@@ -78,7 +79,10 @@ fn erc20_mint_out_of_gas() {
     mint_tx.gas_price = U256::from(GAS_PRICE); // also set non-zero gas price to check gas still charged.
     let outcome = runner.submit_transaction(&source_account.secret_key, mint_tx);
     let error = outcome.unwrap();
-    assert_eq!(error.status, TransactionStatus::OutOfGas);
+    assert_eq!(
+        error.status,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+    );
 
     // Validate post-state
 
@@ -232,7 +236,10 @@ fn deploy_erc_20_out_of_gas() {
     deploy_transaction.gas_limit = U256::from(intrinsic_gas + 1);
     let outcome = runner.submit_transaction(&source_account, deploy_transaction);
     let error = outcome.unwrap();
-    assert_eq!(error.status, TransactionStatus::OutOfGas);
+    assert_eq!(
+        error.status,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+    );
 
     // Validate post-state
     utils::validate_address_balance_and_nonce(

engine-tests/src/tests/sanity.rs

@@ -7,6 +7,7 @@ use aurora_engine_sdk as sdk;
 use aurora_engine_types::borsh::BorshDeserialize;
 #[cfg(not(feature = "ext-connector"))]
 use aurora_engine_types::parameters::connector::FungibleTokenMetadata;
+use aurora_engine_types::parameters::engine::TransactionStatusEvmErrorKind;
 use aurora_engine_types::H160;
 use libsecp256k1::SecretKey;
 use near_vm_runner::ContractCode;
@@ -54,7 +55,10 @@ fn bench_memory_get_standalone() {
         .unwrap();
     let duration = start.elapsed().as_secs_f32();
     assert!(
-        matches!(result.status, TransactionStatus::OutOfGas),
+        matches!(
+            result.status,
+            TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+        ),
         "Infinite loops in the EVM run out of gas"
     );
     assert!(
@@ -108,7 +112,10 @@ fn test_returndatacopy() {
     let address = deploy_contract(&mut runner, &mut signer, contract_bytes);
     let result = call_contract(&mut runner, &mut signer, address);
     assert!(
-        matches!(result.status, TransactionStatus::OutOfGas),
+        matches!(
+            result.status,
+            TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+        ),
         "EVM must run out of gas if len > 0 with large memory offset"
     );
 }
@@ -564,7 +571,10 @@ fn test_create_out_of_gas() {
         })
         .unwrap();
     assert!(
-        matches!(result.status, TransactionStatus::OutOfGas),
+        matches!(
+            result.status,
+            TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+        ),
         "Unexpected status: {:?}",
         result.status
     );
@@ -758,7 +768,10 @@ fn test_eth_transfer_insufficient_balance() {
             utils::transfer(dest_address, INITIAL_BALANCE + INITIAL_BALANCE, nonce)
         })
         .unwrap();
-    assert_eq!(result.status, TransactionStatus::OutOfFund);
+    assert_eq!(
+        result.status,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfGas)
+    );
 
     // validate post-state
     utils::validate_address_balance_and_nonce(
@@ -1067,7 +1080,8 @@ fn test_block_hash_contract() {
         })
         .unwrap();
 
-    utils::panic_on_fail(result.status);
+    let res = utils::panic_on_fail(result.status);
+    assert!(res.is_none(), "Status: {:?}", res);
 }
 
 #[cfg(not(feature = "ext-connector"))]
@@ -1220,7 +1234,9 @@ mod workspace {
     use crate::prelude::{Address, U256};
     use crate::tests::sanity::{GAS_PRICE, INITIAL_BALANCE, INITIAL_NONCE, TRANSFER_AMOUNT};
     use crate::utils;
-    use aurora_engine_types::parameters::engine::TransactionStatus;
+    use aurora_engine_types::parameters::engine::{
+        TransactionStatus, TransactionStatusEvmErrorKind,
+    };
     use aurora_engine_workspace::EngineContract;
 
     // Same as `test_eth_transfer_insufficient_balance` above, except runs through
@@ -1245,13 +1261,23 @@ mod workspace {
             Some(utils::AuroraRunner::default().chain_id),
             &signer.secret_key,
         );
+
+        let res = aurora
+            .submit(rlp::encode(&signed_tx).to_vec())
+            .transact()
+            .await;
+        println!("RES: {:?}", res);
+
         let result = aurora
             .submit(rlp::encode(&signed_tx).to_vec())
             .transact()
             .await
             .unwrap()
             .into_value();
-        assert_eq!(result.status, TransactionStatus::OutOfFund);
+        assert_eq!(
+            result.status,
+            TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfFund)
+        );
 
         // validate post-state
         assert_eq!(

engine-tests/src/tests/serde.rs

@@ -5,12 +5,13 @@ use aurora_engine::{
     parameters::{ResultLog, SubmitResult, TransactionStatus},
 };
 use aurora_engine_transactions::eip_2930::AccessTuple;
+use aurora_engine_types::parameters::engine::TransactionStatusEvmErrorKind;
 use aurora_engine_types::{types::Address, H160};
 
 #[test]
 fn test_serde_submit_result() {
     let result = SubmitResult::new(
-        TransactionStatus::OutOfFund,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfFund),
         0,
         vec![ResultLog {
             address: Address::default(),

engine-tests/src/tests/silo.rs

@@ -2,7 +2,7 @@ use aurora_engine::engine::EngineErrorKind;
 use aurora_engine_sdk as sdk;
 use aurora_engine_types::account_id::AccountId;
 use aurora_engine_types::borsh::BorshSerialize;
-use aurora_engine_types::parameters::engine::TransactionStatus;
+use aurora_engine_types::parameters::engine::{TransactionStatus, TransactionStatusEvmErrorKind};
 use aurora_engine_types::parameters::silo::{
     FixedGasArgs, SiloParamsArgs, WhitelistAccountArgs, WhitelistAddressArgs, WhitelistArgs,
     WhitelistKind, WhitelistStatusArgs,
@@ -99,7 +99,10 @@ fn test_transfer_insufficient_balance() {
             )
         })
         .unwrap();
-    assert_eq!(result.status, TransactionStatus::OutOfFund);
+    assert_eq!(
+        result.status,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfFund)
+    );
 
     // validate post-state
     validate_address_balance_and_nonce(
@@ -164,7 +167,10 @@ fn test_transfer_insufficient_balance_fee() {
             utils::transfer_with_price(receiver, TRANSFER_AMOUNT, nonce, ONE_GAS_PRICE.raw())
         })
         .unwrap();
-    assert!(matches!(result.status, TransactionStatus::OutOfFund));
+    assert!(matches!(
+        result.status,
+        TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfFund)
+    ));
 }
 
 #[test]

engine-tests/src/tests/standard_precompiles.rs

@@ -24,7 +24,8 @@ fn test_standard_precompiles() {
         .submit_with_signer(&mut signer, |nonce| contract.call_method("test_all", nonce))
         .unwrap();
 
-    utils::panic_on_fail(outcome.status);
+    let res = utils::panic_on_fail(outcome.status);
+    assert!(res.is_none(), "Status: {:?}", res);
 }
 
 #[test]

engine-tests/src/tests/xcc.rs

@@ -1054,7 +1054,7 @@ pub mod workspace {
                     .unwrap();
                 anyhow::bail!("TX has been reverted with message: {revert_message}");
             }
-            _ => anyhow::bail!("Wrong status of the transaction"),
+            TransactionStatus::Error(_) => anyhow::bail!("Wrong status of the transaction"),
         }
     }
 

engine-tests/src/utils/mod.rs

@@ -1000,11 +1000,15 @@ pub fn unwrap_revert_slice(result: &SubmitResult) -> &[u8] {
     }
 }
 
-pub fn panic_on_fail(status: TransactionStatus) {
+pub fn panic_on_fail(status: TransactionStatus) -> Option<String> {
     match status {
-        TransactionStatus::Succeed(_) => (),
-        TransactionStatus::Revert(message) => panic!("{}", String::from_utf8_lossy(&message)),
-        other => panic!("{}", String::from_utf8_lossy(other.as_ref())),
+        TransactionStatus::Succeed(_) => None,
+        TransactionStatus::Revert(message) => {
+            Some(format!("Revert: {}", String::from_utf8_lossy(&message)))
+        }
+        TransactionStatus::Error(err) => {
+            Some(format!("Error: {}", String::from_utf8_lossy(err.as_ref())))
+        }
     }
 }
 

engine-tests/src/utils/solidity/exit_precompile.rs

@@ -94,7 +94,9 @@ impl Tester {
         match result.status {
             aurora_engine::parameters::TransactionStatus::Succeed(_) => Ok(result),
             aurora_engine::parameters::TransactionStatus::Revert(_bytes) => Err(Revert),
-            other => panic!("Unexpected status {other:?}"),
+            aurora_engine::parameters::TransactionStatus::Error(err) => {
+                panic!("Unexpected status {err:?}")
+            }
         }
     }
 

engine-types/src/parameters/engine.rs

@@ -247,10 +247,6 @@ pub enum TransactionStatus {
     Succeed(Vec<u8>),
     Revert(Vec<u8>),
     Error(TransactionStatusEvmErrorKind),
-    OutOfGas,
-    OutOfFund,
-    OutOfOffset,
-    CallTooDeep,
 }
 
 impl TransactionStatus {
@@ -265,11 +261,8 @@ impl TransactionStatus {
     }
 
     #[must_use]
-    pub fn is_fail(&self) -> bool {
-        *self == Self::OutOfGas
-            || *self == Self::OutOfFund
-            || *self == Self::OutOfOffset
-            || *self == Self::CallTooDeep
+    pub const fn is_fail(&self) -> bool {
+        matches!(*self, Self::Error(_))
     }
 }
 
@@ -279,10 +272,6 @@ impl AsRef<[u8]> for TransactionStatus {
             Self::Succeed(_) => b"SUCCESS",
             Self::Revert(_) => errors::ERR_REVERT,
             Self::Error(kind) => kind.as_ref(),
-            Self::OutOfFund => errors::ERR_OUT_OF_FUNDS,
-            Self::OutOfGas => errors::ERR_OUT_OF_GAS,
-            Self::OutOfOffset => errors::ERR_OUT_OF_OFFSET,
-            Self::CallTooDeep => errors::ERR_CALL_TOO_DEEP,
         }
     }
 }

engine/src/engine.rs

@@ -859,22 +859,6 @@ impl<'env, I: IO + Copy, E: Env, M: ModExpAlgorithm> Engine<'env, I, E, M> {
                     kind: evm_err.into(),
                     gas_used: submit_result.gas_used,
                 }),
-                TransactionStatus::OutOfFund => Err(EngineError {
-                    kind: EngineErrorKind::EvmError(ExitError::OutOfFund),
-                    gas_used: submit_result.gas_used,
-                }),
-                TransactionStatus::OutOfOffset => Err(EngineError {
-                    kind: EngineErrorKind::EvmError(ExitError::OutOfOffset),
-                    gas_used: submit_result.gas_used,
-                }),
-                TransactionStatus::OutOfGas => Err(EngineError {
-                    kind: EngineErrorKind::EvmError(ExitError::OutOfGas),
-                    gas_used: submit_result.gas_used,
-                }),
-                TransactionStatus::CallTooDeep => Err(EngineError {
-                    kind: EngineErrorKind::EvmError(ExitError::CallTooDeep),
-                    gas_used: submit_result.gas_used,
-                }),
             })
             .inspect_err(|_e| {
                 sdk::log!("{:?}", _e);
@@ -2283,7 +2267,7 @@ mod tests {
         });
         let actual_result = engine.call_with_args(args, &mut handler).unwrap();
 
-        let expected_status = TransactionStatus::OutOfFund;
+        let expected_status = TransactionStatus::Error(TransactionStatusEvmErrorKind::OutOfFund);
         let expected_gas_used = 21000;
         let expected_logs = Vec::new();
         let expected_result = SubmitResult::new(expected_status, expected_gas_used, expected_logs);