perf: replace AccessListInspector with post-execution state-diff blocklist check

Replace the per-opcode AccessListInspector with a post-execution check
against ResultAndState.state (EvmState = HashMap<Address, Account>),
which already contains every address touched during EVM execution.

The AccessListInspector calls step() on every EVM opcode to build an
access list, solely used to check addresses against the blocklist.
Profiling shows this inspector overhead consumes ~52% of CPU time.
The EVM execution result already contains the same information in its
state diff, making the inspector redundant for this purpose.

This optimization works regardless of whether a blocklist is configured:
- Empty blocklist: skip inspector, skip blocklist check
- Non-empty blocklist: skip inspector, check state keys instead

When used_state_tracer is active (parallel builder), the inspector is
still attached for UsedStateEVMInspector, but blocklist checking still
uses the state diff instead of the access list.

Benchmark (builder-lab, 100 TPS contender, 60s profiling window):

| Metric              | Before   | After    | Change |
|---------------------|----------|----------|--------|
| Block fill p50      | 98.8ms   | 57.5ms   | -42%   |
| Block fill p95      | 144.9ms  | 69.1ms   | -52%   |
| E2E latency p50     | 101ms    | 59ms     | -42%   |
| E2E latency p95     | 147ms    | 76ms     | -48%   |
| Avg bid value       | 0.0041   | 0.0075   | +83%   |

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: vbuilder69420

crates/rbuilder/src/building/order_commit.rs

@@ -1162,6 +1162,35 @@ where
     Factory: EvmFactory,
 {
     let tx = tx_with_blobs.internal_tx_unsecure();
+
+    // Skip the AccessListInspector entirely — it calls step() on every EVM opcode
+    // just to track accessed addresses for the blocklist check. Instead, we check
+    // the blocklist against ResultAndState.state (EvmState = HashMap<Address, Account>)
+    // which already contains every address touched during execution.
+    // This eliminates ~50% of CPU overhead during block building.
+    if used_state_tracer.is_none() {
+        let mut evm = evm_factory.create_evm(db, evm_env);
+        let res = match evm.transact(tx) {
+            Ok(res) => res,
+            Err(err) => match err {
+                EVMError::Transaction(tx_err) => {
+                    return Ok(Err(TransactionErr::InvalidTransaction(tx_err)))
+                }
+                EVMError::Database(_) | EVMError::Header(_) | EVMError::Custom(_) => {
+                    return Err(err.into())
+                }
+            },
+        };
+        // Check blocklist against addresses in the execution state diff
+        if !blocklist.is_empty() && res.state.keys().any(|addr| blocklist.contains(addr)) {
+            return Ok(Err(TransactionErr::Blocklist));
+        }
+        return Ok(Ok(res));
+    }
+
+    // Slow path: used_state_tracer is active (parallel builder conflict detection).
+    // Still need the inspector for UsedStateEVMInspector, but we can skip AccessListInspector
+    // and use the state diff for blocklist checking instead.
     let mut rbuilder_inspector = RBuilderEVMInspector::new(tx, used_state_tracer);
 
     let mut evm = evm_factory.create_evm_with_inspector(db, evm_env, &mut rbuilder_inspector);
@@ -1177,8 +1206,8 @@ where
         },
     };
     drop(evm);
-    let access_list = rbuilder_inspector.into_access_list();
-    if access_list.flatten().any(|(a, _)| blocklist.contains(&a)) {
+    // Use state diff for blocklist check instead of access list
+    if !blocklist.is_empty() && res.state.keys().any(|addr| blocklist.contains(addr)) {
         return Ok(Err(TransactionErr::Blocklist));
     }