Enable validating tests

crates/contracts/src/tracer.rs

@@ -30,6 +30,7 @@ pub struct Level {
     pub opcodes: HashMap<String, u64>,
     #[serde(rename = "contractSize")]
     pub contract_size: HashMap<Address, u64>,
+    pub oog: Option<bool>,
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize)]

crates/uopool/src/canonical/simulation.rs

@@ -86,6 +86,7 @@ pub enum SimulateValidationError {
     CodeHashesValidation {
         message: String,
     },
+    OutOfGas {},
     UnknownError {
         error: String,
     },
@@ -140,6 +141,11 @@ impl From<SimulateValidationError> for SimulationError {
             SimulateValidationError::CodeHashesValidation { message } => {
                 SimulationError::owned(OPCODE_VALIDATION_ERROR_CODE, message, None::<bool>)
             }
+            SimulateValidationError::OutOfGas {} => SimulationError::owned(
+                OPCODE_VALIDATION_ERROR_CODE,
+                "UserOperation out of gas",
+                None::<bool>,
+            ),
             SimulateValidationError::UnknownError { error } => {
                 SimulationError::owned(ErrorCode::InternalError.code(), error, None::<bool>)
             }
@@ -311,6 +317,17 @@ impl<M: Middleware + 'static> UoPool<M> {
         };
     }
 
+    fn check_oog(&self, trace: &JsTracerFrame) -> Result<(), SimulateValidationError> {
+        for (index, _) in LEVEL_TO_ENTITY.iter().enumerate() {
+            if let Some(level) = trace.number_levels.get(index) {
+                if level.oog.unwrap_or(false) {
+                    return Err(SimulateValidationError::OutOfGas {});
+                }
+            }
+        }
+        Ok(())
+    }
+
     fn forbidden_opcodes(&self, trace: &JsTracerFrame) -> Result<(), SimulateValidationError> {
         for (index, _) in LEVEL_TO_ENTITY.iter().enumerate() {
             if let Some(level) = trace.number_levels.get(index) {
@@ -533,6 +550,21 @@ impl<M: Middleware + 'static> UoPool<M> {
         let mut calls: Vec<CallEntry> = vec![];
         self.parse_call_stack(trace, &mut calls)?;
 
+        // check recursive call entrypoint method
+        let call_into_entry_point = calls.iter().find(|call| {
+            call.to.unwrap_or_default() == self.entry_point.address()
+                && call.from.unwrap_or_default() != self.entry_point.address()
+                && (call.method.is_some()
+                    && call.method.clone().unwrap_or_default() != *"depositTo")
+        });
+        if call_into_entry_point.is_some() {
+            return Err(SimulateValidationError::CallStackValidation {
+                message: format!(
+                    "illegal call into EntryPoint during validation {call_into_entry_point:?}"
+                ),
+            });
+        }
+
         for (index, stake_info) in stake_info_by_entity.iter().enumerate() {
             if LEVEL_TO_ENTITY[index] == "paymaster" {
                 let call = calls.iter().find(|call| {
@@ -682,6 +714,8 @@ impl<M: Middleware + 'static> UoPool<M> {
                 &mut stake_info_by_entity,
             );
 
+            self.check_oog(&js_trace)?;
+
             // may not invokes any forbidden opcodes
             self.forbidden_opcodes(&js_trace)?;
 

tests/Cargo.toml

@@ -14,6 +14,7 @@ rust-version = "1.69.0"
 [dev-dependencies]
 aa-bundler-contracts = { path = "../crates/contracts" }
 aa-bundler-primitives = { path = "../crates/primitives" }
+aa-bundler-uopool = { path = "../crates/uopool" }
 
 anyhow = "1"
 ethers = { workspace = true }

tests/src/common/gen.rs

@@ -42,3 +42,7 @@ abigen!(
     TracerTest,
     "$CARGO_WORKSPACE_DIR/thirdparty/bundler/packages/bundler/artifacts/contracts/tests/TracerTest.sol/TracerTest.json"
 );
+abigen!(
+    TestCoin,
+    "$CARGO_WORKSPACE_DIR/thirdparty/bundler/packages/bundler/artifacts/contracts/tests/TestCoin.sol/TestCoin.json"
+);

tests/src/common/mod.rs

@@ -13,8 +13,9 @@ use ethers::{
 use tempdir::TempDir;
 
 use self::gen::{
-    EntryPointContract, TestOpcodesAccount, TestOpcodesAccountFactory, TestRecursionAccount,
-    TestRulesAccountFactory, TestStorageAccount, TestStorageAccountFactory, TracerTest,
+    EntryPointContract, TestCoin, TestOpcodesAccount, TestOpcodesAccountFactory,
+    TestRecursionAccount, TestRulesAccountFactory, TestStorageAccount, TestStorageAccountFactory,
+    TracerTest,
 };
 pub mod gen;
 
@@ -67,8 +68,9 @@ pub async fn deploy_test_opcode_account_factory<M: Middleware + 'static>(
 
 pub async fn deploy_test_storage_account_factory<M: Middleware + 'static>(
     client: Arc<M>,
+    test_coin_addr: Address,
 ) -> anyhow::Result<DeployedContract<TestStorageAccountFactory<M>>> {
-    let (factory, receipt) = TestStorageAccountFactory::deploy(client, ())?
+    let (factory, receipt) = TestStorageAccountFactory::deploy(client, test_coin_addr)?
         .send_with_receipt()
         .await?;
     let address = receipt.contract_address.unwrap();
@@ -114,6 +116,14 @@ pub async fn deploy_tracer_test<M: Middleware + 'static>(
     Ok(DeployedContract::new(factory, address))
 }
 
+pub async fn deploy_test_coin<M: Middleware + 'static>(
+    client: Arc<M>,
+) -> anyhow::Result<DeployedContract<TestCoin<M>>> {
+    let (factory, receipt) = TestCoin::deploy(client, ())?.send_with_receipt().await?;
+    let address = receipt.contract_address.unwrap();
+    Ok(DeployedContract::new(factory, address))
+}
+
 pub async fn sign(
     user_op: &mut UserOperation,
     entry_point_address: &Address,