feat: replay preceding block txs for accurate gas estimation

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "contracts/lib/forge-std"]
 	path = contracts/lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
-[submodule "contracts/lib/gas-killer-avs-sol"]
-	path = contracts/lib/gas-killer-avs-sol
-	url = https://github.com/BreadchainCoop/gas-killer-avs-sol
+[submodule "contracts/lib/solidity-sdk"]
+	path = contracts/lib/solidity-sdk
+	url = https://github.com/gas-killer/solidity-sdk

contracts/README.md

@@ -4,7 +4,7 @@ Solidity contracts used by the Gas Analyzer for on-chain gas estimation and inte
 
 ## Contents
 
-- **`src/StateChangeHandlerGasEstimator.sol`** — Wrapper around `StateChangeHandlerLib` from [gas-killer-avs-sol](https://github.com/BreadchainCoop/gas-killer-avs-sol). Deployed to an Anvil fork to measure the actual gas cost of replaying a transaction's state updates.
+- **`src/StateChangeHandlerGasEstimator.sol`** — Wrapper around `StateChangeHandlerLib` from [solidity-sdk](https://github.com/gas-killer/solidity-sdk). Deployed to an Anvil fork to measure the actual gas cost of replaying a transaction's state updates.
 - **`src/AccessControlTestContracts.sol`** — Test contracts for verifying state update extraction across access-controlled calls.
 - **`src/DelegateCallTestContracts.sol`** — Test contracts for verifying correct state update extraction with `DELEGATECALL` (only top-level context changes should be captured).
 - **`script/`** — Foundry deployment scripts for the test contracts.
@@ -18,7 +18,7 @@ Solidity contracts used by the Gas Analyzer for on-chain gas estimation and inte
 ```bash
 cd contracts
 
-# Install dependencies (forge-std, gas-killer-avs-sol)
+# Install dependencies (forge-std, solidity-sdk)
 forge install
 
 # Build

contracts/foundry.lock

@@ -2,7 +2,7 @@
   "lib/forge-std": {
     "rev": "77041d2ce690e692d6e03cc812b57d1ddaa4d505"
   },
-  "lib/gas-killer-avs-sol": {
-    "rev": "33ef63ec63dccf6f7de98778de1cbbf2754489a6"
+  "lib/solidity-sdk": {
+    "rev": "ca0be7078f77e414952e7723c9b92a2d4d4f8e54"
   }
 }

contracts/foundry.toml

@@ -4,7 +4,7 @@ out = "out"
 libs = ["lib"]
 
 remappings = [
-    "gk/=lib/gas-killer-avs-sol/src/"
+    "gk/=lib/solidity-sdk/src/"
 ]
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

contracts/src/SimEnvTestContracts.sol

@@ -12,6 +12,7 @@ interface SimEnvOptsStructs {
         uint256 blockTimestamp;
         uint256 blockGasLimit;
         uint256 blockPrevRandao;
+        uint256 blockBaseFee;
     }
 
     error EnvironmentMismatch(SimEnvOpts expected, SimEnvOpts actual, string explanation);
@@ -23,15 +24,16 @@ interface SimEnvOptsStructs {
 /// @notice Not covered: Blobs (BLOBHASH, BLOBBASEFEE), Block (BLOCKHASH). Possibly more
 contract SimEnvOptsTestMain is SimEnvOptsStructs {
     SimEnvOptsCallee simEnvOptsCallee;
-    
+
     constructor (
         address txOrigin,
         uint256 txGasPrice,
         address blockCoinbase,
         uint256 blockNumber,
         uint256 blockTimestamp,
         uint256 blockGasLimit,
-        uint256 blockPrevRandao
+        uint256 blockPrevRandao,
+        uint256 blockBaseFee
     ) {
         simEnvOptsCallee = new SimEnvOptsCallee(
             txOrigin,
@@ -40,7 +42,8 @@ contract SimEnvOptsTestMain is SimEnvOptsStructs {
             blockNumber,
             blockTimestamp,
             blockGasLimit,
-            blockPrevRandao
+            blockPrevRandao,
+            blockBaseFee
         );
     }
 
@@ -61,7 +64,8 @@ contract SimEnvOptsCallee is SimEnvOptsStructs {
         uint256 blockNumber,
         uint256 blockTimestamp,
         uint256 blockGasLimit,
-        uint256 blockPrevRandao
+        uint256 blockPrevRandao,
+        uint256 blockBaseFee
     ) {
         simEnv.txOrigin = txOrigin;
         simEnv.txGasPrice = txGasPrice;
@@ -70,6 +74,7 @@ contract SimEnvOptsCallee is SimEnvOptsStructs {
         simEnv.blockTimestamp = blockTimestamp;
         simEnv.blockGasLimit = blockGasLimit;
         simEnv.blockPrevRandao = blockPrevRandao;
+        simEnv.blockBaseFee = blockBaseFee;
     }
 
     function test() external {
@@ -82,6 +87,7 @@ contract SimEnvOptsCallee is SimEnvOptsStructs {
         actual.blockTimestamp = block.timestamp;
         actual.blockGasLimit = block.gaslimit;
         actual.blockPrevRandao = block.prevrandao;
+        actual.blockBaseFee = block.basefee;
 
         bool correct = true;
         string memory reason = "Mismatched fields: ";
@@ -113,6 +119,10 @@ contract SimEnvOptsCallee is SimEnvOptsStructs {
             correct = false;
             reason = string.concat(reason, "blockPrevRandao, ");
         }
+        if (actual.blockBaseFee != expected.blockBaseFee) {
+            correct = false;
+            reason = string.concat(reason, "blockBaseFee, ");
+        }
 
         if (!correct) {
             revert EnvironmentMismatch(expected, actual, reason);

contracts/src/StateChangeHandlerGasEstimator.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.13;
 
-import { StateChangeHandlerLib, StateUpdateType } from "../lib/gas-killer-avs-sol/src/StateChangeHandlerLib.sol";
+import { StateChangeHandlerLib, StateUpdateType } from "../lib/solidity-sdk/src/StateChangeHandlerLib.sol";
 
 /// @notice Gas estimator with transparent-proxy fallback.
 ///

crates/cli/src/main.rs

@@ -116,6 +116,9 @@ async fn execute_command(cli_args: CliArgs) -> Result<()> {
             let block_number = receipt
                 .block_number
                 .expect("couldn't retrieve block number");
+            let tx_index = receipt
+                .transaction_index
+                .expect("couldn't retrieve transaction index");
             let gas_used = receipt.gas_used;
             let original_status = receipt.status();
             let tx_sender = receipt.from;
@@ -296,9 +299,37 @@ async fn execute_command(cli_args: CliArgs) -> Result<()> {
                         .build()
                         .await?;
 
-                    // Try measured gas estimation first
-                    match gk.estimate_state_changes_gas(contract_address, tx_sender, &state_updates)
-                    {
+                    // Fetch preceding transactions for mid-block state accuracy.
+                    // We fail hard here rather than falling back to block-N-1 state:
+                    // a silent fallback can produce a confidently wrong gas number for
+                    // any tx that depends on mid-block state.
+                    let preceding_txs = gas_analyzer_rpc::get_preceding_transactions(
+                        &provider,
+                        block_number,
+                        tx_index,
+                    )
+                    .await
+                    .map_err(|e| {
+                        anyhow::Error::msg(format!(
+                            "Failed to fetch preceding transactions for block {} (tx index {}): {}",
+                            block_number, tx_index, e
+                        ))
+                    })?;
+
+                    if !preceding_txs.is_empty() {
+                        println!(
+                            "Replaying {} preceding transaction(s) for accurate mid-block state...",
+                            preceding_txs.len()
+                        );
+                    }
+
+                    // Try measured gas estimation with preceding tx replay
+                    match gk.estimate_state_changes_gas_with_preceding(
+                        contract_address,
+                        tx_sender,
+                        &state_updates,
+                        &preceding_txs,
+                    ) {
                         Ok(gas) => (gas + TURETZKY_UPPER_GAS_LIMIT, false),
                         Err(e) => {
                             // Fall back to heuristic estimation
@@ -378,9 +409,10 @@ async fn execute_command(cli_args: CliArgs) -> Result<()> {
                 println!("\n{}", "=== Gas Analysis ===".blue().bold());
                 println!("Transaction: 0x{}", hex::encode(bytes));
                 println!(
-                    "Block: {} ({})",
+                    "Block: {} ({}) | Tx Index: {}",
                     block_number,
-                    receipt.block_hash.unwrap_or_default()
+                    receipt.block_hash.unwrap_or_default(),
+                    tx_index
                 );
                 println!("Gas used: {}", gas_used);
                 let estimate_type = if use_fallback {

crates/core/src/trace.rs

@@ -28,9 +28,15 @@ pub fn copy_memory(memory: &[u8], offset: usize, length: usize) -> Vec<u8> {
 }
 
 /// Parse trace memory from Geth format (hex strings) to bytes.
+///
+/// Accepts entries with or without an `0x` prefix — Anvil began emitting prefixed
+/// memory words after revm-inspectors v0.38.1 (Foundry v1.7.0), while geth/erigon
+/// and older Anvil emit bare hex.
 pub fn parse_trace_memory(memory: Vec<String>) -> Vec<u8> {
     memory
-        .join("")
+        .iter()
+        .map(|s| s.strip_prefix("0x").unwrap_or(s))
+        .collect::<String>()
         .chars()
         .collect::<Vec<char>>()
         .chunks(2)
@@ -253,3 +259,32 @@ pub fn compute_state_updates(
 
     Ok((state_updates, skipped_opcodes, total_call_gas))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_trace_memory_handles_both_prefixed_and_bare_hex() {
+        let bare = vec![
+            "00000000000000000000000000000000000000000000000000000000000000ff".to_string(),
+            "1100000000000000000000000000000000000000000000000000000000000000".to_string(),
+        ];
+        let prefixed = vec![
+            "0x00000000000000000000000000000000000000000000000000000000000000ff".to_string(),
+            "0x1100000000000000000000000000000000000000000000000000000000000000".to_string(),
+        ];
+        let mixed = vec![
+            "0x00000000000000000000000000000000000000000000000000000000000000ff".to_string(),
+            "1100000000000000000000000000000000000000000000000000000000000000".to_string(),
+        ];
+
+        let expected = parse_trace_memory(bare);
+        assert_eq!(expected.len(), 64);
+        assert_eq!(expected[31], 0xff);
+        assert_eq!(expected[32], 0x11);
+
+        assert_eq!(parse_trace_memory(prefixed), expected);
+        assert_eq!(parse_trace_memory(mixed), expected);
+    }
+}

crates/evmsketch/Cargo.toml

@@ -9,6 +9,7 @@ gas-analyzer-rpc = { path = "../rpc" }
 gas-analyzer-estimator = { path = "../gas-estimator" }
 alloy = { version = "1.0.37", features = ["rpc", "rpc-types"] }
 alloy-eips = "1.0.37"
+alloy-evm = "0.25"
 alloy-provider = { version = "1.0.37", features = ["debug-api"] }
 anyhow = "1.0.98"
 tokio = { version = "1", features = ["rt"] }
@@ -17,3 +18,12 @@ reth-primitives = { git = "https://github.com/paradigmxyz/reth", tag = "v1.9.1"
 revm = { version = "31.0.1" }
 sp1-cc-host-executor = { git = "https://github.com/BreadchainCoop/sp1-contract-call", branch = "cancun-v1", package = "sp1-cc-host-executor" }
 sp1-cc-client-executor = { git = "https://github.com/BreadchainCoop/sp1-contract-call", branch = "cancun-v1", package = "sp1-cc-client-executor" }
+
+[dev-dependencies]
+alloy-consensus = "1"
+alloy-hardforks = "0.4"
+alloy-json-rpc = "1"
+alloy-rpc-client = "1"
+alloy-transport = "1"
+tokio = { version = "1", features = ["rt", "rt-multi-thread", "macros"] }
+tower = "0.5"