What is the difference between simulate_execution and simulate_handle_op？

[octavei]

in crates/uopool/src/uopool.rs,
code:

match self.entry_point.simulate_execution(uo.clone()).await {
            Ok(_) => {}
            Err(err) => {
                return Err(match err {
                    EntryPointErr::JsonRpcError(err) => SimulationError::Execution {
                        message: err.message,
                    },
                    _ => SimulationError::UnknownError {
                        message: format!("{err:?}"),
                    },
                })
            }
        }

        let exec_res = match self.entry_point.simulate_handle_op(uo.clone()).await {
            Ok(res) => res,
            Err(err) => {
                return Err(match err {
                    EntryPointErr::JsonRpcError(err) => SimulationError::Execution {
                        message: err.message,
                    },
                    _ => SimulationError::UnknownError {
                        message: format!("{err:?}"),
                    },
                })
            }
        };

What is the difference between simulate_execution and simulate_handle_op？

[octavei]

You know, I mean, why does a CallData execute here twice? In other words, What is the role of the simulate_execution method？

[octavei]

code in crates/contracts/src/entry_point.rs

pub async fn simulate_execution<U: Into<UserOperation>>(
        &self,
        uo: U,
    ) -> Result<(), EntryPointErr> {
        let uo: UserOperation = uo.into();

        let res = self
            .eth_client
            .call(
                &TransactionRequest::new()
                    .from(self.address)
                    .to(uo.sender)
                    .data(uo.call_data.clone())
                    .into(),
                None,
            )
            .await;

        match res {
            Ok(_) => Ok(()),
            Err(e) => Err(EntryPointErr::from_middleware_err::<M>(e)),
        }
    }

    pub async fn simulate_handle_op<U: Into<UserOperation>>(
        &self,
        uo: U,
    ) -> Result<ExecutionResult, EntryPointErr> {
        let res = self
            .entry_point_api
            .simulate_handle_op(uo.into(), Address::zero(), Bytes::default())
            .await;

        match res {
            Ok(_) => Err(EntryPointErr::UnknownErr(
                "Simulate handle op should expect revert".to_string(),
            )),
            Err(e) => Self::deserialize_error_msg(e).and_then(|op| match op {
                EntryPointAPIErrors::FailedOp(err) => Err(EntryPointErr::FailedOp(err)),
                EntryPointAPIErrors::ExecutionResult(res) => Ok(res),
                _ => Err(EntryPointErr::UnknownErr(format!(
                    "Simulate handle op with invalid error: {op:?}"
                ))),
            }),
        }
    }

[zsluedem]

This is a good question. I think @Vid201 should be a better person to answer this.
I would share my opinion here.
simulate_execution would make sure the operation(callData) would be valid operation and it is faster to do the check first.
simulate_handle_op would use the function https://github.com/eth-infinitism/account-abstraction/blob/develop/contracts/core/EntryPoint.sol#L184 directly to run what real execution would do and return the more appropriate gas estimation. Based on the experiences from other bundlers, estimateGas needs more work to be more accurate.

Better hear what @Vid201 explains.

[Vid201]

Exactly what @zsluedem said

I will just add the following (for estimating user operation gas):

• At the beginning of the function, we simulate the validation of the user operation
• Then we need to simulate execution, so we can throw any errors that could happen during execution (the first check only performs validation, a big part of 4337 is this division into validation and execution)
• And simulate handle op is used for estimating the gas costs of user operation, which is one of the ways to do it, but there is no consensus between bundlers yet what is exactly the best approach

[octavei]

Why in the transaction pool, there are only check and simulate_validation but no simulate_execution? In this way, we can know more precisely which ops were finally successfully executed.

[Vid201]

Because for the actual bundling, bundler doesn't care if the user operation will revert during execution, it only cares that it will be paid (which is validation). This is the same scenario as with Ethereum nodes and transactions.