diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index acd6295b7c..5794580f03 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -87,12 +87,12 @@ jobs:
         uses: actions/cache@v3
         with:
           path: |
-            ~/.cargo/registry/
-            ~/.cargo/git/
+            ~/.cargo/
             arbitrator/target/
             arbitrator/wasm-libraries/target/
-            arbitrator/wasm-libraries/soft-float/SoftFloat/build
+            arbitrator/wasm-libraries/soft-float/
             target/etc/initial-machine-cache/
+            /home/runner/.rustup/toolchains/
           key: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-min-${{ hashFiles('arbitrator/Cargo.lock') }}-${{ matrix.test-mode }}
           restore-keys: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-
 
@@ -145,89 +145,42 @@ jobs:
         env:
           TEST_STATE_SCHEME: path
         run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/... -timeout 20m -tags=cionly > >(stdbuf -oL tee -a full.log | grep -vE "INFO|seal"); then
-              exit 1
-            fi
-          done
+          echo "Running tests with Path Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags cionly --timeout 20m --cover
 
       - name: run tests without race detection and hash state scheme
         if: matrix.test-mode == 'defaults'
         env:
           TEST_STATE_SCHEME: hash
         run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -timeout 20m -tags=cionly; then
-              exit 1
-            fi
-          done
-
-      - name: run tests with race detection and path state scheme
-        if: matrix.test-mode == 'race'
-        env:
-          TEST_STATE_SCHEME: path
-        run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -race -timeout 30m > >(stdbuf -oL tee -a full.log | grep -vE "INFO|seal"); then
-              exit 1
-            fi
-          done
+          echo "Running tests with Hash Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags cionly --timeout 20m
 
       - name: run tests with race detection and hash state scheme
         if: matrix.test-mode == 'race'
         env:
           TEST_STATE_SCHEME: hash
         run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -race -timeout 30m; then
-              exit 1
-            fi
-          done
+          echo "Running tests with Hash Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --race --timeout 30m
 
       - name: run redis tests
         if: matrix.test-mode == 'defaults'
-        run: TEST_REDIS=redis://localhost:6379/0 gotestsum --format short-verbose -- -p 1 -run TestRedis ./arbnode/... ./system_tests/... -coverprofile=coverage-redis.txt -covermode=atomic -coverpkg=./...
+        run: |
+          echo "Running redis tests" >> full.log
+          TEST_REDIS=redis://localhost:6379/0 gotestsum --format short-verbose -- -p 1 -run TestRedis ./arbnode/... ./system_tests/... -coverprofile=coverage-redis.txt -covermode=atomic -coverpkg=./...
 
       - name: run challenge tests
         if: matrix.test-mode == 'challenge'
-        run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/... -tags=challengetest -run=TestChallenge > >(stdbuf -oL tee -a full.log | grep -vE "INFO|seal"); then
-              exit 1
-            fi
-          done
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags challengetest --run TestChallenge --cover
 
       - name: run stylus tests
         if: matrix.test-mode == 'stylus'
-        run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -timeout 60m -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/... -tags=stylustest -run="TestProgramArbitrator" > >(stdbuf -oL tee -a full.log | grep -vE "INFO|seal"); then
-              exit 1
-            fi
-          done
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags stylustest --run TestProgramArbitrator --timeout 60m --cover
 
       - name: run long stylus tests
         if: matrix.test-mode == 'long'
-        run: |
-          packages=`go list ./...`
-          for package in $packages; do
-            echo running tests for $package
-            if ! stdbuf -oL gotestsum --format short-verbose --packages="$package" --rerun-fails=2 --no-color=false -- -timeout 60m -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/... -tags=stylustest -run="TestProgramLong" > >(stdbuf -oL tee -a full.log | grep -vE "INFO|seal"); then
-              exit 1
-            fi
-          done
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags stylustest --run TestProgramLong --timeout 60m --cover
 
       - name: Archive detailed run log
         uses: actions/upload-artifact@v3
diff --git a/.github/workflows/gotestsum.sh b/.github/workflows/gotestsum.sh
new file mode 100755
index 0000000000..ed631847b7
--- /dev/null
+++ b/.github/workflows/gotestsum.sh
@@ -0,0 +1,83 @@
+#!/bin/bash
+
+check_missing_value() {
+    if [[ $1 -eq 0 || $2 == -* ]]; then
+        echo "missing $3 argument value"
+        exit 1
+    fi
+}
+
+timeout=""
+tags=""
+run=""
+race=false
+cover=false
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --timeout)
+      shift
+      check_missing_value $# "$1" "--timeout"
+      timeout=$1
+      shift
+      ;;
+    --tags)
+      shift
+      check_missing_value $# "$1" "--tags"
+      tags=$1
+      shift
+      ;;
+    --run)
+      shift
+      check_missing_value $# "$1" "--run"
+      run=$1
+      shift
+      ;;
+    --race)
+      race=true
+      shift
+      ;;
+    --cover)
+      cover=true
+      shift
+      ;;
+    *)
+      echo "Invalid argument: $1"
+      exit 1
+      ;;
+  esac
+done
+
+packages=$(go list ./...)
+for package in $packages; do
+  cmd="stdbuf -oL gotestsum --format short-verbose --packages=\"$package\" --rerun-fails=2 --no-color=false --"
+
+  if [ "$timeout" != "" ]; then
+    cmd="$cmd -timeout $timeout"
+  fi
+
+  if [ "$tags" != "" ]; then
+    cmd="$cmd -tags=$tags"
+  fi
+
+  if [ "$run" != "" ]; then
+    cmd="$cmd -run=$run"
+  fi
+
+  if [ "$race" == true ]; then
+    cmd="$cmd -race"
+  fi
+
+  if [ "$cover" == true ]; then
+    cmd="$cmd -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/..."
+  fi
+
+  cmd="$cmd > >(stdbuf -oL tee -a full.log | grep -vE \"INFO|seal\")"
+
+  echo ""
+  echo running tests for "$package"
+  echo "$cmd"
+
+  if ! eval "$cmd"; then
+    exit 1
+  fi
+done
diff --git a/.github/workflows/shellcheck-ci.yml b/.github/workflows/shellcheck-ci.yml
new file mode 100644
index 0000000000..d1c7b58580
--- /dev/null
+++ b/.github/workflows/shellcheck-ci.yml
@@ -0,0 +1,30 @@
+name: ShellCheck CI
+run-name: ShellCheck CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  shellcheck:
+    name: Run ShellCheck
+    runs-on: ubuntu-8
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Run ShellCheck
+        uses: ludeeus/action-shellcheck@master
+        with:
+          ignore_paths: >-
+            ./fastcache/**
+            ./contracts/**
+            ./safe-smart-account/**
+            ./go-ethereum/**
+            ./nitro-testnode/**
+            ./brotli/**
+            ./arbitrator/**
diff --git a/.github/workflows/submodule-pin-check.sh b/.github/workflows/submodule-pin-check.sh
deleted file mode 100755
index aecb287ce1..0000000000
--- a/.github/workflows/submodule-pin-check.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-
-declare -Ar exceptions=(
-	[contracts]=origin/develop
-	[nitro-testnode]=origin/master
-
-	#TODO Rachel to check these are the intended branches.
-	[arbitrator/langs/c]=origin/vm-storage-cache
-	[arbitrator/tools/wasmer]=origin/adopt-v4.2.8
-)
-
-divergent=0
-for mod in `git submodule --quiet foreach 'echo $name'`; do
-	branch=origin/HEAD
-	if [[ -v exceptions[$mod] ]]; then
-		branch=${exceptions[$mod]}
-	fi
-
-	if ! git -C $mod merge-base --is-ancestor HEAD $branch; then
-		echo $mod diverges from $branch
-		divergent=1
-	fi
-done
-
-exit $divergent
-
diff --git a/.github/workflows/submodule-pin-check.yml b/.github/workflows/submodule-pin-check.yml
index f045f71f68..90419b530e 100644
--- a/.github/workflows/submodule-pin-check.yml
+++ b/.github/workflows/submodule-pin-check.yml
@@ -18,11 +18,32 @@ jobs:
         with:
           fetch-depth: 0
           submodules: true
+          ref: "${{ github.event.pull_request.merge_commit_sha }}"
 
       - name: Check all submodules are ancestors of origin/HEAD or configured branch
         run: |
           status_state="pending"
-          if ${{ github.workspace }}/.github/workflows/submodule-pin-check.sh; then
+          declare -Ar exceptions=(
+            [contracts]=origin/develop
+            [nitro-testnode]=origin/master
+            
+            #TODO Rachel to check these are the intended branches.
+            [arbitrator/langs/c]=origin/vm-storage-cache
+            [arbitrator/tools/wasmer]=origin/adopt-v4.2.8
+          )
+          divergent=0
+          for mod in `git submodule --quiet foreach 'echo $name'`; do
+            branch=origin/HEAD
+            if [[ -v exceptions[$mod] ]]; then
+              branch=${exceptions[$mod]}
+            fi
+            
+            if ! git -C $mod merge-base --is-ancestor HEAD $branch; then
+              echo $mod diverges from $branch
+              divergent=1
+            fi
+          done
+          if [ $divergent -eq 0 ]; then
             status_state="success"
           else
             resp="$(curl -sSL --fail-with-body \
diff --git a/Dockerfile b/Dockerfile
index 37226c397c..9138ed30ad 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -218,6 +218,7 @@ COPY ./scripts/download-machine.sh .
 #RUN ./download-machine.sh consensus-v20 0x8b104a2e80ac6165dc58b9048de12f301d70b02a0ab51396c22b4b4b802a16a4
 RUN ./download-machine.sh consensus-v30 0xb0de9cb89e4d944ae6023a3b62276e54804c242fd8c4c2d8e6cc4450f5fa8b1b && true
 RUN ./download-machine.sh consensus-v31 0x260f5fa5c3176a856893642e149cf128b5a8de9f828afec8d11184415dd8dc69
+RUN ./download-machine.sh consensus-v32 0x184884e1eb9fefdc158f6c8ac912bb183bf3cf83f0090317e0bc4ac5860baa39
 
 FROM golang:1.21.10-bookworm AS node-builder
 WORKDIR /workspace
diff --git a/LICENSE.md b/LICENSE.md
index ea9a53da75..25768b3010 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -22,7 +22,7 @@ Additional Use Grant: You may use the Licensed Work in a production environment
                       Expansion Program Term of Use](https://docs.arbitrum.foundation/assets/files/Arbitrum%20Expansion%20Program%20Jan182024-4f08b0c2cb476a55dc153380fa3e64b0.pdf). For purposes of this
                       Additional Use Grant, the "Covered Arbitrum Chains" are 
                       (a) Arbitrum One (chainid:42161), Arbitrum Nova (chainid:42170), 
-                      rbitrum Rinkeby testnet/Rinkarby (chainid:421611),Arbitrum Nitro
+                      Arbitrum Rinkeby testnet/Rinkarby (chainid:421611),Arbitrum Nitro
                       Goerli testnet (chainid:421613), and Arbitrum Sepolia Testnet
                       (chainid:421614); (b) any future blockchains authorized to be
                       designated as Covered Arbitrum Chains by the decentralized autonomous
diff --git a/Makefile b/Makefile
index 0a71d64f12..c3cf1a5144 100644
--- a/Makefile
+++ b/Makefile
@@ -283,6 +283,7 @@ clean:
 	rm -f arbitrator/wasm-libraries/soft-float/SoftFloat/build/Wasm-Clang/*.a
 	rm -f arbitrator/wasm-libraries/forward/*.wat
 	rm -rf arbitrator/stylus/tests/*/target/ arbitrator/stylus/tests/*/*.wasm
+	rm -rf brotli/buildfiles
 	@rm -rf contracts/build contracts/cache solgen/go/
 	@rm -f .make/*
 
diff --git a/arbcompress/native.go b/arbcompress/native.go
index 8244010979..f7b8f0b8e0 100644
--- a/arbcompress/native.go
+++ b/arbcompress/native.go
@@ -7,7 +7,7 @@
 package arbcompress
 
 /*
-#cgo CFLAGS: -g -Wall -I${SRCDIR}/../target/include/
+#cgo CFLAGS: -g -I${SRCDIR}/../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../target/lib/libstylus.a -lm
 #include "arbitrator.h"
 */
diff --git a/arbitrator/Cargo.lock b/arbitrator/Cargo.lock
index 79a9117a31..2b437968fa 100644
--- a/arbitrator/Cargo.lock
+++ b/arbitrator/Cargo.lock
@@ -215,7 +215,6 @@ dependencies = [
  "prover",
  "serde",
  "serde_json",
- "serde_with 3.9.0",
 ]
 
 [[package]]
@@ -496,6 +495,12 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
+[[package]]
+name = "clru"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbd0f76e066e64fdc5631e3bb46381254deab9ef1158292f27c8c57e3bf3fe59"
+
 [[package]]
 name = "colorchoice"
 version = "1.0.2"
@@ -705,38 +710,14 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "darling"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
-dependencies = [
- "darling_core 0.13.4",
- "darling_macro 0.13.4",
-]
-
 [[package]]
 name = "darling"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.10",
- "darling_macro 0.20.10",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
@@ -753,24 +734,13 @@ dependencies = [
  "syn 2.0.72",
 ]
 
-[[package]]
-name = "darling_macro"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
-dependencies = [
- "darling_core 0.13.4",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "darling_macro"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.20.10",
+ "darling_core",
  "quote",
  "syn 2.0.72",
 ]
@@ -928,7 +898,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59c3b24c345d8c314966bdc1832f6c2635bfcce8e7cf363bd115987bba2ee242"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -1750,7 +1720,7 @@ dependencies = [
  "rustc-demangle",
  "serde",
  "serde_json",
- "serde_with 1.14.0",
+ "serde_with",
  "sha2 0.9.9",
  "sha3 0.9.1",
  "smallvec",
@@ -2073,16 +2043,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_with"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff"
-dependencies = [
- "serde",
- "serde_with_macros 1.5.2",
-]
-
 [[package]]
 name = "serde_with"
 version = "3.9.0"
@@ -2097,29 +2057,17 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "serde_with_macros 3.9.0",
+ "serde_with_macros",
  "time",
 ]
 
-[[package]]
-name = "serde_with_macros"
-version = "1.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082"
-dependencies = [
- "darling 0.13.4",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "serde_with_macros"
 version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -2226,12 +2174,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -2270,13 +2212,13 @@ dependencies = [
  "bincode",
  "brotli",
  "caller-env",
+ "clru",
  "derivative",
  "eyre",
  "fnv",
  "hex",
  "lazy_static",
  "libc",
- "lru",
  "num-bigint",
  "parking_lot",
  "prover",
diff --git a/arbitrator/Cargo.toml b/arbitrator/Cargo.toml
index 94ca08b0b5..eaafb6e439 100644
--- a/arbitrator/Cargo.toml
+++ b/arbitrator/Cargo.toml
@@ -24,9 +24,7 @@ repository = "https://github.com/OffchainLabs/nitro.git"
 rust-version = "1.67"
 
 [workspace.dependencies]
-cfg-if = "1.0.0"
 lazy_static = "1.4.0"
-lru = "0.12.3"
 num_enum = { version = "0.7.2", default-features = false }
 ruint2 = "1.9.0"
 wasmparser = "0.121"
diff --git a/arbitrator/arbutil/src/evm/api.rs b/arbitrator/arbutil/src/evm/api.rs
index 093e7f2984..9d4c78c0de 100644
--- a/arbitrator/arbutil/src/evm/api.rs
+++ b/arbitrator/arbutil/src/evm/api.rs
@@ -77,7 +77,7 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
     /// Reads the 32-byte value in the EVM state trie at offset `key`.
     /// Returns the value and the access cost in gas.
     /// Analogous to `vm.SLOAD`.
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64);
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64);
 
     /// Stores the given value at the given key in Stylus VM's cache of the EVM state trie.
     /// Note that the actual values only get written after calls to `set_trie_slots`.
diff --git a/arbitrator/arbutil/src/evm/mod.rs b/arbitrator/arbutil/src/evm/mod.rs
index 1671e67072..36dadd906a 100644
--- a/arbitrator/arbutil/src/evm/mod.rs
+++ b/arbitrator/arbutil/src/evm/mod.rs
@@ -74,9 +74,12 @@ pub const GASPRICE_GAS: u64 = GAS_QUICK_STEP;
 // vm.GasQuickStep (see jump_table.go)
 pub const ORIGIN_GAS: u64 = GAS_QUICK_STEP;
 
+pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32;
+
 #[derive(Clone, Copy, Debug, Default)]
 #[repr(C)]
 pub struct EvmData {
+    pub arbos_version: u64,
     pub block_basefee: Bytes32,
     pub chainid: u64,
     pub block_coinbase: Bytes20,
diff --git a/arbitrator/arbutil/src/evm/req.rs b/arbitrator/arbutil/src/evm/req.rs
index 287db357f3..0304f2d378 100644
--- a/arbitrator/arbutil/src/evm/req.rs
+++ b/arbitrator/arbutil/src/evm/req.rs
@@ -7,7 +7,6 @@ use crate::{
         storage::{StorageCache, StorageWord},
         user::UserOutcomeKind,
     },
-    pricing::EVM_API_INK,
     Bytes20, Bytes32,
 };
 use eyre::{bail, eyre, Result};
@@ -99,13 +98,13 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApiRequestor<D, H> {
 }
 
 impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let cache = &mut self.storage_cache;
         let mut cost = cache.read_gas();
 
         let value = cache.entry(key).or_insert_with(|| {
             let (res, _, gas) = self.handler.request(EvmApiMethod::GetBytes32, key);
-            cost = cost.saturating_add(gas).saturating_add(EVM_API_INK);
+            cost = cost.saturating_add(gas).saturating_add(evm_api_gas_to_use);
             StorageWord::known(res.try_into().unwrap())
         });
         (value.value, cost)
@@ -299,9 +298,10 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         let mut request = Vec::with_capacity(2 * 8 + 3 * 2 + name.len() + args.len() + outs.len());
         request.extend(start_ink.to_be_bytes());
         request.extend(end_ink.to_be_bytes());
-        request.extend((name.len() as u16).to_be_bytes());
-        request.extend((args.len() as u16).to_be_bytes());
-        request.extend((outs.len() as u16).to_be_bytes());
+        // u32 is enough to represent the slices lengths because the WASM environment runs in 32 bits.
+        request.extend((name.len() as u32).to_be_bytes());
+        request.extend((args.len() as u32).to_be_bytes());
+        request.extend((outs.len() as u32).to_be_bytes());
         request.extend(name.as_bytes());
         request.extend(args);
         request.extend(outs);
diff --git a/arbitrator/arbutil/src/types.rs b/arbitrator/arbutil/src/types.rs
index 6cf1d6cdf7..722a89b81e 100644
--- a/arbitrator/arbutil/src/types.rs
+++ b/arbitrator/arbutil/src/types.rs
@@ -8,6 +8,7 @@ use std::{
     borrow::Borrow,
     fmt,
     ops::{Deref, DerefMut},
+    str::FromStr,
 };
 
 // These values must be kept in sync with `arbutil/preimage_type.go`,
@@ -83,6 +84,32 @@ impl From<usize> for Bytes32 {
     }
 }
 
+impl FromStr for Bytes32 {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Remove the "0x" prefix if present
+        let s = s.strip_prefix("0x").unwrap_or(s);
+
+        // Pad with leading zeros if the string is shorter than 64 characters (32 bytes)
+        let padded = format!("{:0>64}", s);
+
+        // Decode the hex string using the hex crate
+        let decoded_bytes = hex::decode(padded).map_err(|_| "Invalid hex string")?;
+
+        // Ensure the decoded bytes is exactly 32 bytes
+        if decoded_bytes.len() != 32 {
+            return Err("Hex string too long for Bytes32");
+        }
+
+        // Create a 32-byte array and fill it with the decoded bytes.
+        let mut b = [0u8; 32];
+        b.copy_from_slice(&decoded_bytes);
+
+        Ok(Bytes32(b))
+    }
+}
+
 impl TryFrom<&[u8]> for Bytes32 {
     type Error = std::array::TryFromSliceError;
 
@@ -249,3 +276,77 @@ impl From<GenericBytes20> for Bytes20 {
         <[u8; 20]>::from(x).into()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_bytes32() {
+        let b = Bytes32::from(0x12345678u32);
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_short() {
+        // Short hex string
+        let b = Bytes32::from_str("0x12345678").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_very_short() {
+        // Short hex string
+        let b = Bytes32::from_str("0x1").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0x1,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_no_prefix() {
+        // Short hex string
+        let b = Bytes32::from_str("12345678").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_full() {
+        // Full-length hex string
+        let b =
+            Bytes32::from_str("0x0000000000000000000000000000000000000000000000000000000012345678")
+                .unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_invalid_non_hex() {
+        let s = "0x123g5678"; // Invalid character 'g'
+        assert!(Bytes32::from_str(s).is_err());
+    }
+
+    #[test]
+    fn test_from_str_too_big() {
+        let s =
+            "0123456789ABCDEF0123456789ABCDEF01234567890123456789ABCDEF01234567890123456789ABCDEF0"; // 65 characters
+        assert!(Bytes32::from_str(s).is_err());
+    }
+}
diff --git a/arbitrator/bench/Cargo.toml b/arbitrator/bench/Cargo.toml
index 3ab5b99b08..74b948aca8 100644
--- a/arbitrator/bench/Cargo.toml
+++ b/arbitrator/bench/Cargo.toml
@@ -3,10 +3,6 @@ name = "bench"
 version = "0.1.0"
 edition = "2021"
 
-[lib]
-name = "bench"
-path = "src/lib.rs"
-
 [[bin]]
 name = "benchbin"
 path = "src/bin.rs"
@@ -20,7 +16,6 @@ clap = { version = "4.4.8", features = ["derive"] }
 gperftools = { version = "0.2.0", optional = true }
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.67"
-serde_with = { version = "3.8.1", features = ["base64"] }
 
 [features]
 counters = []
diff --git a/arbitrator/bench/src/bin.rs b/arbitrator/bench/src/bin.rs
index f7e69f5373..60a7036e2b 100644
--- a/arbitrator/bench/src/bin.rs
+++ b/arbitrator/bench/src/bin.rs
@@ -1,6 +1,5 @@
 use std::{path::PathBuf, time::Duration};
 
-use bench::prepare::*;
 use clap::Parser;
 use eyre::bail;
 
@@ -10,11 +9,12 @@ use gperftools::profiler::PROFILER;
 #[cfg(feature = "heapprof")]
 use gperftools::heap_profiler::HEAP_PROFILER;
 
-use prover::machine::MachineStatus;
-
 #[cfg(feature = "counters")]
 use prover::{machine, memory, merkle};
 
+use prover::machine::MachineStatus;
+use prover::prepare::prepare_machine;
+
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Args {
diff --git a/arbitrator/bench/src/lib.rs b/arbitrator/bench/src/lib.rs
deleted file mode 100644
index 5f7c024094..0000000000
--- a/arbitrator/bench/src/lib.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod parse_input;
-pub mod prepare;
diff --git a/arbitrator/bench/src/parse_input.rs b/arbitrator/bench/src/parse_input.rs
deleted file mode 100644
index decc67372a..0000000000
--- a/arbitrator/bench/src/parse_input.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use arbutil::Bytes32;
-use serde::{Deserialize, Serialize};
-use serde_json;
-use serde_with::base64::Base64;
-use serde_with::As;
-use serde_with::DisplayFromStr;
-use std::{
-    collections::HashMap,
-    io::{self, BufRead},
-};
-
-mod prefixed_hex {
-    use serde::{self, Deserialize, Deserializer, Serializer};
-
-    pub fn serialize<S>(bytes: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&format!("0x{}", hex::encode(bytes)))
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        if let Some(s) = s.strip_prefix("0x") {
-            hex::decode(s).map_err(serde::de::Error::custom)
-        } else {
-            Err(serde::de::Error::custom("missing 0x prefix"))
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct PreimageMap(HashMap<Bytes32, Vec<u8>>);
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "PascalCase")]
-pub struct BatchInfo {
-    pub number: u64,
-    #[serde(with = "As::<Base64>")]
-    pub data_b64: Vec<u8>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "PascalCase")]
-pub struct StartState {
-    #[serde(with = "prefixed_hex")]
-    pub block_hash: Vec<u8>,
-    #[serde(with = "prefixed_hex")]
-    pub send_root: Vec<u8>,
-    pub batch: u64,
-    pub pos_in_batch: u64,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-#[serde(rename_all = "PascalCase")]
-pub struct FileData {
-    pub id: u64,
-    pub has_delayed_msg: bool,
-    pub delayed_msg_nr: u64,
-    #[serde(with = "As::<HashMap<DisplayFromStr, HashMap<Base64, Base64>>>")]
-    pub preimages_b64: HashMap<u32, HashMap<Bytes32, Vec<u8>>>,
-    pub batch_info: Vec<BatchInfo>,
-    #[serde(with = "As::<Base64>")]
-    pub delayed_msg_b64: Vec<u8>,
-    pub start_state: StartState,
-}
-
-impl FileData {
-    pub fn from_reader<R: BufRead>(mut reader: R) -> io::Result<Self> {
-        let data = serde_json::from_reader(&mut reader)?;
-        Ok(data)
-    }
-}
diff --git a/arbitrator/jit/src/machine.rs b/arbitrator/jit/src/machine.rs
index 2a3c5c5616..02523f740a 100644
--- a/arbitrator/jit/src/machine.rs
+++ b/arbitrator/jit/src/machine.rs
@@ -129,7 +129,9 @@ pub fn create(opts: &Opts, env: WasmEnv) -> (Instance, FunctionEnv<WasmEnv>, Sto
             "send_response" => func!(program::send_response),
             "create_stylus_config" => func!(program::create_stylus_config),
             "create_evm_data" => func!(program::create_evm_data),
+            "create_evm_data_v2" => func!(program::create_evm_data_v2),
             "activate" => func!(program::activate),
+            "activate_v2" => func!(program::activate_v2),
         },
     };
 
diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs
index c608a3cf85..084afe96bc 100644
--- a/arbitrator/jit/src/program.rs
+++ b/arbitrator/jit/src/program.rs
@@ -16,8 +16,45 @@ use prover::{
     programs::{config::PricingParams, prelude::*},
 };
 
-/// activates a user program
+const DEFAULT_STYLUS_ARBOS_VERSION: u64 = 31;
+
 pub fn activate(
+    env: WasmEnvMut,
+    wasm_ptr: GuestPtr,
+    wasm_size: u32,
+    pages_ptr: GuestPtr,
+    asm_estimate_ptr: GuestPtr,
+    init_cost_ptr: GuestPtr,
+    cached_init_cost_ptr: GuestPtr,
+    stylus_version: u16,
+    debug: u32,
+    codehash: GuestPtr,
+    module_hash_ptr: GuestPtr,
+    gas_ptr: GuestPtr,
+    err_buf: GuestPtr,
+    err_buf_len: u32,
+) -> Result<u32, Escape> {
+    activate_v2(
+        env,
+        wasm_ptr,
+        wasm_size,
+        pages_ptr,
+        asm_estimate_ptr,
+        init_cost_ptr,
+        cached_init_cost_ptr,
+        stylus_version,
+        DEFAULT_STYLUS_ARBOS_VERSION,
+        debug,
+        codehash,
+        module_hash_ptr,
+        gas_ptr,
+        err_buf,
+        err_buf_len,
+    )
+}
+
+/// activates a user program
+pub fn activate_v2(
     mut env: WasmEnvMut,
     wasm_ptr: GuestPtr,
     wasm_size: u32,
@@ -25,7 +62,8 @@ pub fn activate(
     asm_estimate_ptr: GuestPtr,
     init_cost_ptr: GuestPtr,
     cached_init_cost_ptr: GuestPtr,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: u32,
     codehash: GuestPtr,
     module_hash_ptr: GuestPtr,
@@ -40,7 +78,15 @@ pub fn activate(
 
     let page_limit = mem.read_u16(pages_ptr);
     let gas_left = &mut mem.read_u64(gas_ptr);
-    match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) {
+    match Module::activate(
+        &wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas_left,
+    ) {
         Ok((module, data)) => {
             mem.write_u64(gas_ptr, *gas_left);
             mem.write_u16(pages_ptr, data.footprint);
@@ -222,9 +268,47 @@ pub fn create_stylus_config(
     Ok(res as u64)
 }
 
-/// Creates an `EvmData` handler from its component parts.
 pub fn create_evm_data(
+    env: WasmEnvMut,
+    block_basefee_ptr: GuestPtr,
+    chainid: u64,
+    block_coinbase_ptr: GuestPtr,
+    block_gas_limit: u64,
+    block_number: u64,
+    block_timestamp: u64,
+    contract_address_ptr: GuestPtr,
+    module_hash_ptr: GuestPtr,
+    msg_sender_ptr: GuestPtr,
+    msg_value_ptr: GuestPtr,
+    tx_gas_price_ptr: GuestPtr,
+    tx_origin_ptr: GuestPtr,
+    cached: u32,
+    reentrant: u32,
+) -> Result<u64, Escape> {
+    create_evm_data_v2(
+        env,
+        DEFAULT_STYLUS_ARBOS_VERSION,
+        block_basefee_ptr,
+        chainid,
+        block_coinbase_ptr,
+        block_gas_limit,
+        block_number,
+        block_timestamp,
+        contract_address_ptr,
+        module_hash_ptr,
+        msg_sender_ptr,
+        msg_value_ptr,
+        tx_gas_price_ptr,
+        tx_origin_ptr,
+        cached,
+        reentrant,
+    )
+}
+
+/// Creates an `EvmData` handler from its component parts.
+pub fn create_evm_data_v2(
     mut env: WasmEnvMut,
+    arbos_version: u64,
     block_basefee_ptr: GuestPtr,
     chainid: u64,
     block_coinbase_ptr: GuestPtr,
@@ -243,6 +327,7 @@ pub fn create_evm_data(
     let (mut mem, _) = env.jit_env();
 
     let evm_data = EvmData {
+        arbos_version,
         block_basefee: mem.read_bytes32(block_basefee_ptr),
         cached: cached != 0,
         chainid,
diff --git a/arbitrator/prover/Cargo.toml b/arbitrator/prover/Cargo.toml
index 5475647765..da329b1cb5 100644
--- a/arbitrator/prover/Cargo.toml
+++ b/arbitrator/prover/Cargo.toml
@@ -19,10 +19,10 @@ num = "0.4"
 rustc-demangle = "0.1.21"
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.67"
+serde_with = { version = "3.8.1", features = ["base64"] }
 sha3 = "0.9.1"
 static_assertions = "1.1.0"
 structopt = "0.3.23"
-serde_with = "1.12.1"
 parking_lot = "0.12.1"
 lazy_static.workspace = true
 itertools = "0.10.5"
diff --git a/arbitrator/prover/src/binary.rs b/arbitrator/prover/src/binary.rs
index aa5537476c..2260f6bf48 100644
--- a/arbitrator/prover/src/binary.rs
+++ b/arbitrator/prover/src/binary.rs
@@ -9,7 +9,9 @@ use crate::{
     },
     value::{ArbValueType, FunctionType, IntegerValType, Value},
 };
-use arbutil::{math::SaturatingSum, Bytes32, Color, DebugColor};
+use arbutil::{
+    evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES, math::SaturatingSum, Bytes32, Color, DebugColor,
+};
 use eyre::{bail, ensure, eyre, Result, WrapErr};
 use fnv::{FnvHashMap as HashMap, FnvHashSet as HashSet};
 use nom::{
@@ -641,6 +643,7 @@ impl<'a> WasmBinary<'a> {
     /// Parses and instruments a user wasm
     pub fn parse_user(
         wasm: &'a [u8],
+        arbos_version_for_gas: u64,
         page_limit: u16,
         compile: &CompileConfig,
         codehash: &Bytes32,
@@ -678,6 +681,10 @@ impl<'a> WasmBinary<'a> {
             limit!(65536, code.expr.len(), "opcodes in func body");
         }
 
+        if arbos_version_for_gas >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            limit!(513, bin.imports.len(), "imports")
+        }
+
         let table_entries = bin.tables.iter().map(|x| x.initial).saturating_sum();
         limit!(4096, table_entries, "table entries");
 
diff --git a/arbitrator/prover/src/lib.rs b/arbitrator/prover/src/lib.rs
index 0f537478eb..08473c2598 100644
--- a/arbitrator/prover/src/lib.rs
+++ b/arbitrator/prover/src/lib.rs
@@ -11,6 +11,8 @@ pub mod machine;
 /// cbindgen:ignore
 pub mod memory;
 pub mod merkle;
+pub mod parse_input;
+pub mod prepare;
 mod print;
 pub mod programs;
 mod reinterpret;
diff --git a/arbitrator/prover/src/machine.rs b/arbitrator/prover/src/machine.rs
index 358876bd25..4ece1f7bf2 100644
--- a/arbitrator/prover/src/machine.rs
+++ b/arbitrator/prover/src/machine.rs
@@ -371,13 +371,16 @@ impl Module {
         for import in &bin.imports {
             let module = import.module;
             let have_ty = &bin.types[import.offset as usize];
-            let (forward, import_name) = match import.name.strip_prefix(Module::FORWARDING_PREFIX) {
-                Some(name) => (true, name),
-                None => (false, import.name),
-            };
+            // allow_hostapi is only set for system modules like the
+            // forwarder. We restrict stripping the prefix for user modules.
+            let (forward, import_name) =
+                if allow_hostapi && import.name.starts_with(Self::FORWARDING_PREFIX) {
+                    (true, &import.name[Self::FORWARDING_PREFIX.len()..])
+                } else {
+                    (false, import.name)
+                };
 
-            let mut qualified_name = format!("{module}__{import_name}");
-            qualified_name = qualified_name.replace(&['/', '.', '-'] as &[char], "_");
+            let qualified_name = format!("{module}__{import_name}");
 
             let func = if let Some(import) = available_imports.get(&qualified_name) {
                 let call = match forward {
diff --git a/arbitrator/prover/src/main.rs b/arbitrator/prover/src/main.rs
index dba32e0e72..a889cc60f3 100644
--- a/arbitrator/prover/src/main.rs
+++ b/arbitrator/prover/src/main.rs
@@ -8,6 +8,7 @@ use eyre::{eyre, Context, Result};
 use fnv::{FnvHashMap as HashMap, FnvHashSet as HashSet};
 use prover::{
     machine::{GlobalState, InboxIdentifier, Machine, MachineStatus, PreimageResolver, ProofInfo},
+    prepare::prepare_machine,
     utils::{file_bytes, hash_preimage, CBytes},
     wavm::Opcode,
 };
@@ -86,6 +87,10 @@ struct Opts {
     skip_until_host_io: bool,
     #[structopt(long)]
     max_steps: Option<u64>,
+    // JSON inputs supercede any of the command-line inputs which could
+    // be specified in the JSON file.
+    #[structopt(long)]
+    json_inputs: Option<PathBuf>,
 }
 
 fn file_with_stub_header(path: &Path, headerlength: usize) -> Result<Vec<u8>> {
@@ -135,83 +140,8 @@ fn main() -> Result<()> {
             }
         }
     }
-    let mut inbox_contents = HashMap::default();
-    let mut inbox_position = opts.inbox_position;
-    let mut delayed_position = opts.delayed_inbox_position;
-    let inbox_header_len;
-    let delayed_header_len;
-    if opts.inbox_add_stub_headers {
-        inbox_header_len = INBOX_HEADER_LEN;
-        delayed_header_len = DELAYED_HEADER_LEN + 1;
-    } else {
-        inbox_header_len = 0;
-        delayed_header_len = 0;
-    }
-
-    for path in opts.inbox {
-        inbox_contents.insert(
-            (InboxIdentifier::Sequencer, inbox_position),
-            file_with_stub_header(&path, inbox_header_len)?,
-        );
-        println!("read file {:?} to seq. inbox {}", &path, inbox_position);
-        inbox_position += 1;
-    }
-    for path in opts.delayed_inbox {
-        inbox_contents.insert(
-            (InboxIdentifier::Delayed, delayed_position),
-            file_with_stub_header(&path, delayed_header_len)?,
-        );
-        delayed_position += 1;
-    }
 
-    let mut preimages: HashMap<PreimageType, HashMap<Bytes32, CBytes>> = HashMap::default();
-    if let Some(path) = opts.preimages {
-        let mut file = BufReader::new(File::open(path)?);
-        loop {
-            let mut ty_buf = [0u8; 1];
-            match file.read_exact(&mut ty_buf) {
-                Ok(()) => {}
-                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
-                Err(e) => return Err(e.into()),
-            }
-            let preimage_ty: PreimageType = ty_buf[0].try_into()?;
-
-            let mut size_buf = [0u8; 8];
-            file.read_exact(&mut size_buf)?;
-            let size = u64::from_le_bytes(size_buf) as usize;
-            let mut buf = vec![0u8; size];
-            file.read_exact(&mut buf)?;
-
-            let hash = hash_preimage(&buf, preimage_ty)?;
-            preimages
-                .entry(preimage_ty)
-                .or_default()
-                .insert(hash.into(), buf.as_slice().into());
-        }
-    }
-    let preimage_resolver =
-        Arc::new(move |_, ty, hash| preimages.get(&ty).and_then(|m| m.get(&hash)).cloned())
-            as PreimageResolver;
-
-    let last_block_hash = decode_hex_arg(&opts.last_block_hash, "--last-block-hash")?;
-    let last_send_root = decode_hex_arg(&opts.last_send_root, "--last-send-root")?;
-
-    let global_state = GlobalState {
-        u64_vals: [opts.inbox_position, opts.position_within_message],
-        bytes32_vals: [last_block_hash, last_send_root],
-    };
-
-    let mut mach = Machine::from_paths(
-        &opts.libraries,
-        &opts.binary,
-        true,
-        opts.allow_hostapi,
-        opts.debug_funcs,
-        true,
-        global_state,
-        inbox_contents,
-        preimage_resolver,
-    )?;
+    let mut mach = initialize_machine(&opts)?;
 
     for path in &opts.stylus_modules {
         let err = || eyre!("failed to read module at {}", path.to_string_lossy().red());
@@ -414,6 +344,13 @@ fn main() -> Result<()> {
         });
     }
 
+    println!(
+        "End GlobalState:\n  BlockHash: {:?}\n  SendRoot: {:?}\n  Batch: {}\n  PosInBatch: {}",
+        mach.get_global_state().bytes32_vals[0],
+        mach.get_global_state().bytes32_vals[1],
+        mach.get_global_state().u64_vals[0],
+        mach.get_global_state().u64_vals[1]
+    );
     println!("End machine status: {:?}", mach.get_status());
     println!("End machine hash: {}", mach.hash());
     println!("End machine stack: {:?}", mach.get_data_stack());
@@ -462,7 +399,6 @@ fn main() -> Result<()> {
                 }
             }
         }
-
         let opts_binary = opts.binary;
         let opts_libraries = opts.libraries;
         let format_pc = |module_num: usize, func_num: usize| -> (String, String) {
@@ -543,3 +479,87 @@ fn main() -> Result<()> {
     }
     Ok(())
 }
+
+fn initialize_machine(opts: &Opts) -> eyre::Result<Machine> {
+    if let Some(json_inputs) = opts.json_inputs.clone() {
+        prepare_machine(json_inputs, opts.binary.clone())
+    } else {
+        let mut inbox_contents = HashMap::default();
+        let mut inbox_position = opts.inbox_position;
+        let mut delayed_position = opts.delayed_inbox_position;
+        let inbox_header_len;
+        let delayed_header_len;
+        if opts.inbox_add_stub_headers {
+            inbox_header_len = INBOX_HEADER_LEN;
+            delayed_header_len = DELAYED_HEADER_LEN + 1;
+        } else {
+            inbox_header_len = 0;
+            delayed_header_len = 0;
+        }
+
+        for path in opts.inbox.clone() {
+            inbox_contents.insert(
+                (InboxIdentifier::Sequencer, inbox_position),
+                file_with_stub_header(&path, inbox_header_len)?,
+            );
+            println!("read file {:?} to seq. inbox {}", &path, inbox_position);
+            inbox_position += 1;
+        }
+        for path in opts.delayed_inbox.clone() {
+            inbox_contents.insert(
+                (InboxIdentifier::Delayed, delayed_position),
+                file_with_stub_header(&path, delayed_header_len)?,
+            );
+            delayed_position += 1;
+        }
+
+        let mut preimages: HashMap<PreimageType, HashMap<Bytes32, CBytes>> = HashMap::default();
+        if let Some(path) = opts.preimages.clone() {
+            let mut file = BufReader::new(File::open(path)?);
+            loop {
+                let mut ty_buf = [0u8; 1];
+                match file.read_exact(&mut ty_buf) {
+                    Ok(()) => {}
+                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
+                    Err(e) => return Err(e.into()),
+                }
+                let preimage_ty: PreimageType = ty_buf[0].try_into()?;
+
+                let mut size_buf = [0u8; 8];
+                file.read_exact(&mut size_buf)?;
+                let size = u64::from_le_bytes(size_buf) as usize;
+                let mut buf = vec![0u8; size];
+                file.read_exact(&mut buf)?;
+
+                let hash = hash_preimage(&buf, preimage_ty)?;
+                preimages
+                    .entry(preimage_ty)
+                    .or_default()
+                    .insert(hash.into(), buf.as_slice().into());
+            }
+        }
+        let preimage_resolver =
+            Arc::new(move |_, ty, hash| preimages.get(&ty).and_then(|m| m.get(&hash)).cloned())
+                as PreimageResolver;
+
+        let last_block_hash = decode_hex_arg(&opts.last_block_hash, "--last-block-hash")?;
+        let last_send_root = decode_hex_arg(&opts.last_send_root, "--last-send-root")?;
+
+        let global_state = GlobalState {
+            u64_vals: [opts.inbox_position, opts.position_within_message],
+            bytes32_vals: [last_block_hash, last_send_root],
+        };
+
+        Machine::from_paths(
+            &opts.libraries,
+            &opts.binary,
+            true,
+            opts.allow_hostapi,
+            opts.debug_funcs,
+            true,
+            global_state,
+            inbox_contents,
+            preimage_resolver,
+        )
+    }
+}
diff --git a/arbitrator/prover/src/parse_input.rs b/arbitrator/prover/src/parse_input.rs
new file mode 100644
index 0000000000..fa7adb4c41
--- /dev/null
+++ b/arbitrator/prover/src/parse_input.rs
@@ -0,0 +1,112 @@
+use arbutil::Bytes32;
+use serde::Deserialize;
+use serde_json;
+use serde_with::base64::Base64;
+use serde_with::As;
+use serde_with::DisplayFromStr;
+use std::{
+    collections::HashMap,
+    io::{self, BufRead},
+};
+
+/// prefixed_hex deserializes hex strings which are prefixed with `0x`
+///
+/// The default hex deserializer does not support prefixed hex strings.
+///
+/// It is an error to use this deserializer on a string that does not
+/// begin with `0x`.
+mod prefixed_hex {
+    use serde::{self, Deserialize, Deserializer};
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        if let Some(s) = s.strip_prefix("0x") {
+            hex::decode(s).map_err(serde::de::Error::custom)
+        } else {
+            Err(serde::de::Error::custom("missing 0x prefix"))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UserWasm(Vec<u8>);
+
+/// UserWasm is a wrapper around Vec<u8>
+///
+/// It is useful for decompressing a brotli-compressed wasm module.
+///
+/// Note: The wrapped Vec<u8> is already Base64 decoded before
+/// from(Vec<u8>) is called by serde.
+impl UserWasm {
+    /// as_vec returns the decompressed wasm module as a Vec<u8>
+    pub fn as_vec(&self) -> Vec<u8> {
+        self.0.clone()
+    }
+}
+
+impl AsRef<[u8]> for UserWasm {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// The Vec<u8> is compressed using brotli, and must be decompressed before use.
+impl From<Vec<u8>> for UserWasm {
+    fn from(data: Vec<u8>) -> Self {
+        let decompressed = brotli::decompress(&data, brotli::Dictionary::Empty).unwrap();
+        Self(decompressed)
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct BatchInfo {
+    pub number: u64,
+    #[serde(with = "As::<Base64>")]
+    pub data_b64: Vec<u8>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct StartState {
+    #[serde(with = "prefixed_hex")]
+    pub block_hash: Vec<u8>,
+    #[serde(with = "prefixed_hex")]
+    pub send_root: Vec<u8>,
+    pub batch: u64,
+    pub pos_in_batch: u64,
+}
+
+/// FileData is the deserialized form of the input JSON file.
+///
+/// The go JSON library in json.go uses some custom serialization and
+/// compression logic that needs to be reversed when deserializing the
+/// JSON in rust.
+///
+/// Note: It is important to change this file whenever the go JSON
+/// serialization changes.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct FileData {
+    pub id: u64,
+    pub has_delayed_msg: bool,
+    pub delayed_msg_nr: u64,
+    #[serde(with = "As::<HashMap<DisplayFromStr, HashMap<Base64, Base64>>>")]
+    pub preimages_b64: HashMap<u32, HashMap<Bytes32, Vec<u8>>>,
+    pub batch_info: Vec<BatchInfo>,
+    #[serde(with = "As::<Base64>")]
+    pub delayed_msg_b64: Vec<u8>,
+    pub start_state: StartState,
+    #[serde(with = "As::<HashMap<DisplayFromStr, HashMap<DisplayFromStr, Base64>>>")]
+    pub user_wasms: HashMap<String, HashMap<Bytes32, UserWasm>>,
+}
+
+impl FileData {
+    pub fn from_reader<R: BufRead>(mut reader: R) -> io::Result<Self> {
+        let data = serde_json::from_reader(&mut reader)?;
+        Ok(data)
+    }
+}
diff --git a/arbitrator/bench/src/prepare.rs b/arbitrator/prover/src/prepare.rs
similarity index 85%
rename from arbitrator/bench/src/prepare.rs
rename to arbitrator/prover/src/prepare.rs
index 741a7350ac..a485267f39 100644
--- a/arbitrator/bench/src/prepare.rs
+++ b/arbitrator/prover/src/prepare.rs
@@ -1,13 +1,13 @@
 use arbutil::{Bytes32, PreimageType};
-use prover::machine::{argument_data_to_inbox, GlobalState, Machine};
-use prover::utils::CBytes;
 use std::collections::HashMap;
 use std::fs::File;
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
+use crate::machine::{argument_data_to_inbox, GlobalState, Machine};
 use crate::parse_input::*;
+use crate::utils::CBytes;
 
 pub fn prepare_machine(preimages: PathBuf, machines: PathBuf) -> eyre::Result<Machine> {
     let file = File::open(preimages)?;
@@ -40,6 +40,15 @@ pub fn prepare_machine(preimages: PathBuf, machines: PathBuf) -> eyre::Result<Ma
         u64_vals,
     };
 
+    for (arch, wasm) in data.user_wasms.iter() {
+        if arch != "wavm" {
+            continue;
+        }
+        for (id, wasm) in wasm.iter() {
+            mach.add_stylus_module(*id, wasm.as_vec());
+        }
+    }
+
     mach.set_global_state(start_state);
 
     mach.set_preimage_resolver(preimage_resolver);
diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs
index a5df2e31a8..a35308e7ff 100644
--- a/arbitrator/prover/src/programs/mod.rs
+++ b/arbitrator/prover/src/programs/mod.rs
@@ -8,7 +8,7 @@ use crate::{
     programs::config::CompileConfig,
     value::{FunctionType as ArbFunctionType, Value},
 };
-use arbutil::{math::SaturatingSum, Bytes32, Color};
+use arbutil::{evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES, math::SaturatingSum, Bytes32, Color};
 use eyre::{bail, eyre, Report, Result, WrapErr};
 use fnv::FnvHashMap as HashMap;
 use std::fmt::Debug;
@@ -418,58 +418,64 @@ impl Module {
     pub fn activate(
         wasm: &[u8],
         codehash: &Bytes32,
-        version: u16,
+        stylus_version: u16,
+        arbos_version_for_gas: u64, // must only be used for activation gas
         page_limit: u16,
         debug: bool,
         gas: &mut u64,
     ) -> Result<(Self, StylusData)> {
-        // converts a number of microseconds to gas
-        // TODO: collapse to a single value after finalizing factors
-        let us_to_gas = |us: u64| {
-            let fudge = 2;
-            let sync_rate = 1_000_000 / 2;
-            let speed = 7_000_000;
-            us.saturating_mul(fudge * speed) / sync_rate
-        };
-
-        macro_rules! pay {
-            ($us:expr) => {
-                let amount = us_to_gas($us);
-                if *gas < amount {
-                    *gas = 0;
-                    bail!("out of gas");
-                }
-                *gas -= amount;
+        let compile = CompileConfig::version(stylus_version, debug);
+        let (bin, stylus_data) =
+            WasmBinary::parse_user(wasm, arbos_version_for_gas, page_limit, &compile, codehash)
+                .wrap_err("failed to parse wasm")?;
+
+        if arbos_version_for_gas > 0 {
+            // converts a number of microseconds to gas
+            // TODO: collapse to a single value after finalizing factors
+            let us_to_gas = |us: u64| {
+                let fudge = 2;
+                let sync_rate = 1_000_000 / 2;
+                let speed = 7_000_000;
+                us.saturating_mul(fudge * speed) / sync_rate
             };
-        }
-
-        // pay for wasm
-        let wasm_len = wasm.len() as u64;
-        pay!(wasm_len.saturating_mul(31_733 / 100_000));
-
-        let compile = CompileConfig::version(version, debug);
-        let (bin, stylus_data) = WasmBinary::parse_user(wasm, page_limit, &compile, codehash)
-            .wrap_err("failed to parse wasm")?;
 
-        // pay for funcs
-        let funcs = bin.functions.len() as u64;
-        pay!(funcs.saturating_mul(17_263) / 100_000);
-
-        // pay for data
-        let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64;
-        pay!(data.saturating_mul(17_376) / 100_000);
-
-        // pay for elements
-        let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64;
-        pay!(elems.saturating_mul(17_376) / 100_000);
-
-        // pay for memory
-        let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default();
-        pay!(mem.saturating_mul(2217));
-
-        // pay for code
-        let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64;
-        pay!(code.saturating_mul(535) / 1_000);
+            macro_rules! pay {
+                ($us:expr) => {
+                    let amount = us_to_gas($us);
+                    if *gas < amount {
+                        *gas = 0;
+                        bail!("out of gas");
+                    }
+                    *gas -= amount;
+                };
+            }
+
+            // pay for wasm
+            if arbos_version_for_gas >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+                let wasm_len = wasm.len() as u64;
+                pay!(wasm_len.saturating_mul(31_733) / 100_000);
+            }
+
+            // pay for funcs
+            let funcs = bin.functions.len() as u64;
+            pay!(funcs.saturating_mul(17_263) / 100_000);
+
+            // pay for data
+            let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64;
+            pay!(data.saturating_mul(17_376) / 100_000);
+
+            // pay for elements
+            let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64;
+            pay!(elems.saturating_mul(17_376) / 100_000);
+
+            // pay for memory
+            let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default();
+            pay!(mem.saturating_mul(2217));
+
+            // pay for code
+            let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64;
+            pay!(code.saturating_mul(535) / 1_000);
+        }
 
         let module = Self::from_user_binary(&bin, compile.debug.debug_funcs, Some(stylus_data))
             .wrap_err("failed to build user module")?;
diff --git a/arbitrator/stylus/Cargo.toml b/arbitrator/stylus/Cargo.toml
index 4717bd631a..ea1d878ea0 100644
--- a/arbitrator/stylus/Cargo.toml
+++ b/arbitrator/stylus/Cargo.toml
@@ -21,11 +21,11 @@ thiserror = "1.0.33"
 bincode = "1.3.3"
 lazy_static.workspace = true
 libc = "0.2.108"
-lru.workspace = true
 eyre = "0.6.5"
 rand = "0.8.5"
 fnv = "1.0.7"
 hex = "0.4.3"
+clru = "0.6.2"
 
 [dev-dependencies]
 num-bigint = "0.4.4"
diff --git a/arbitrator/stylus/src/cache.rs b/arbitrator/stylus/src/cache.rs
index fa38d45419..c1fdaaccee 100644
--- a/arbitrator/stylus/src/cache.rs
+++ b/arbitrator/stylus/src/cache.rs
@@ -2,18 +2,19 @@
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
 use arbutil::Bytes32;
+use clru::{CLruCache, CLruCacheConfig, WeightScale};
 use eyre::Result;
 use lazy_static::lazy_static;
-use lru::LruCache;
 use parking_lot::Mutex;
 use prover::programs::config::CompileConfig;
+use std::hash::RandomState;
 use std::{collections::HashMap, num::NonZeroUsize};
 use wasmer::{Engine, Module, Store};
 
 use crate::target_cache::target_native;
 
 lazy_static! {
-    static ref INIT_CACHE: Mutex<InitCache> = Mutex::new(InitCache::new(256));
+    static ref INIT_CACHE: Mutex<InitCache> = Mutex::new(InitCache::new(256 * 1024 * 1024));
 }
 
 macro_rules! cache {
@@ -22,9 +23,16 @@ macro_rules! cache {
     };
 }
 
+pub struct LruCounters {
+    pub hits: u32,
+    pub misses: u32,
+    pub does_not_fit: u32,
+}
+
 pub struct InitCache {
     long_term: HashMap<CacheKey, CacheItem>,
-    lru: LruCache<CacheKey, CacheItem>,
+    lru: CLruCache<CacheKey, CacheItem, RandomState, CustomWeightScale>,
+    lru_counters: LruCounters,
 }
 
 #[derive(Clone, Copy, Hash, PartialEq, Eq)]
@@ -48,11 +56,16 @@ impl CacheKey {
 struct CacheItem {
     module: Module,
     engine: Engine,
+    entry_size_estimate_bytes: usize,
 }
 
 impl CacheItem {
-    fn new(module: Module, engine: Engine) -> Self {
-        Self { module, engine }
+    fn new(module: Module, engine: Engine, entry_size_estimate_bytes: usize) -> Self {
+        Self {
+            module,
+            engine,
+            entry_size_estimate_bytes,
+        }
     }
 
     fn data(&self) -> (Module, Store) {
@@ -60,23 +73,66 @@ impl CacheItem {
     }
 }
 
+struct CustomWeightScale;
+impl WeightScale<CacheKey, CacheItem> for CustomWeightScale {
+    fn weight(&self, _key: &CacheKey, val: &CacheItem) -> usize {
+        // clru defines that each entry consumes (weight + 1) of the cache capacity.
+        // We subtract 1 since we only want to use the weight as the size of the entry.
+        val.entry_size_estimate_bytes.saturating_sub(1)
+    }
+}
+
+#[repr(C)]
+pub struct LruCacheMetrics {
+    pub size_bytes: u64,
+    pub count: u32,
+    pub hits: u32,
+    pub misses: u32,
+    pub does_not_fit: u32,
+}
+
+pub fn deserialize_module(
+    module: &[u8],
+    version: u16,
+    debug: bool,
+) -> Result<(Module, Engine, usize)> {
+    let engine = CompileConfig::version(version, debug).engine(target_native());
+    let module = unsafe { Module::deserialize_unchecked(&engine, module)? };
+
+    let asm_size_estimate_bytes = module.serialize()?.len();
+    // add 128 bytes for the cache item overhead
+    let entry_size_estimate_bytes = asm_size_estimate_bytes + 128;
+
+    Ok((module, engine, entry_size_estimate_bytes))
+}
+
 impl InitCache {
     // current implementation only has one tag that stores to the long_term
     // future implementations might have more, but 0 is a reserved tag
     // that will never modify long_term state
     const ARBOS_TAG: u32 = 1;
 
-    fn new(size: usize) -> Self {
+    const DOES_NOT_FIT_MSG: &'static str = "Failed to insert into LRU cache, item too large";
+
+    fn new(size_bytes: usize) -> Self {
         Self {
             long_term: HashMap::new(),
-            lru: LruCache::new(NonZeroUsize::new(size).unwrap()),
+            lru: CLruCache::with_config(
+                CLruCacheConfig::new(NonZeroUsize::new(size_bytes).unwrap())
+                    .with_scale(CustomWeightScale),
+            ),
+            lru_counters: LruCounters {
+                hits: 0,
+                misses: 0,
+                does_not_fit: 0,
+            },
         }
     }
 
-    pub fn set_lru_size(size: u32) {
+    pub fn set_lru_capacity(capacity_bytes: u64) {
         cache!()
             .lru
-            .resize(NonZeroUsize::new(size.try_into().unwrap()).unwrap())
+            .resize(NonZeroUsize::new(capacity_bytes.try_into().unwrap()).unwrap())
     }
 
     /// Retrieves a cached value, updating items as necessary.
@@ -91,8 +147,11 @@ impl InitCache {
 
         // See if the item is in the LRU cache, promoting if so
         if let Some(item) = cache.lru.get(&key) {
-            return Some(item.data());
+            let data = item.data();
+            cache.lru_counters.hits += 1;
+            return Some(data);
         }
+        cache.lru_counters.misses += 1;
         None
     }
 
@@ -116,20 +175,24 @@ impl InitCache {
             if long_term_tag == Self::ARBOS_TAG {
                 cache.long_term.insert(key, item.clone());
             } else {
-                cache.lru.promote(&key)
+                // only calls get to move the key to the head of the LRU list
+                cache.lru.get(&key);
             }
             return Ok(item.data());
         }
         drop(cache);
 
-        let engine = CompileConfig::version(version, debug).engine(target_native());
-        let module = unsafe { Module::deserialize_unchecked(&engine, module)? };
+        let (module, engine, entry_size_estimate_bytes) =
+            deserialize_module(module, version, debug)?;
 
-        let item = CacheItem::new(module, engine);
+        let item = CacheItem::new(module, engine, entry_size_estimate_bytes);
         let data = item.data();
         let mut cache = cache!();
         if long_term_tag != Self::ARBOS_TAG {
-            cache.lru.put(key, item);
+            if cache.lru.put_with_weight(key, item).is_err() {
+                cache.lru_counters.does_not_fit += 1;
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            };
         } else {
             cache.long_term.insert(key, item);
         }
@@ -144,7 +207,9 @@ impl InitCache {
         let key = CacheKey::new(module_hash, version, debug);
         let mut cache = cache!();
         if let Some(item) = cache.long_term.remove(&key) {
-            cache.lru.put(key, item);
+            if cache.lru.put_with_weight(key, item).is_err() {
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            }
         }
     }
 
@@ -155,7 +220,48 @@ impl InitCache {
         let mut cache = cache!();
         let cache = &mut *cache;
         for (key, item) in cache.long_term.drain() {
-            cache.lru.put(key, item); // not all will fit, just a heuristic
+            // not all will fit, just a heuristic
+            if cache.lru.put_with_weight(key, item).is_err() {
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            }
         }
     }
+
+    pub fn get_lru_metrics() -> LruCacheMetrics {
+        let mut cache = cache!();
+
+        let count = cache.lru.len();
+        let metrics = LruCacheMetrics {
+            // add 1 to each entry to account that we subtracted 1 in the weight calculation
+            size_bytes: (cache.lru.weight() + count).try_into().unwrap(),
+
+            count: count.try_into().unwrap(),
+
+            hits: cache.lru_counters.hits,
+            misses: cache.lru_counters.misses,
+            does_not_fit: cache.lru_counters.does_not_fit,
+        };
+
+        // Empty counters.
+        // go side, which is the only consumer of this function besides tests,
+        // will read those counters and increment its own prometheus counters with them.
+        cache.lru_counters = LruCounters {
+            hits: 0,
+            misses: 0,
+            does_not_fit: 0,
+        };
+
+        metrics
+    }
+
+    // only used for testing
+    pub fn clear_lru_cache() {
+        let mut cache = cache!();
+        cache.lru.clear();
+        cache.lru_counters = LruCounters {
+            hits: 0,
+            misses: 0,
+            does_not_fit: 0,
+        };
+    }
 }
diff --git a/arbitrator/stylus/src/host.rs b/arbitrator/stylus/src/host.rs
index fbe5657c5f..1afc1b4e51 100644
--- a/arbitrator/stylus/src/host.rs
+++ b/arbitrator/stylus/src/host.rs
@@ -13,6 +13,7 @@ use arbutil::{
 };
 use caller_env::GuestPtr;
 use eyre::Result;
+use prover::value::Value;
 use std::{
     fmt::Display,
     mem::{self, MaybeUninit},
@@ -440,76 +441,26 @@ pub(crate) fn pay_for_memory_grow<D: DataReader, E: EvmApi<D>>(
     hostio!(env, pay_for_memory_grow(pages))
 }
 
-pub(crate) mod console {
-    use super::*;
-
-    pub(crate) fn log_txt<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        ptr: GuestPtr,
-        len: u32,
-    ) -> MaybeEscape {
-        hostio!(env, console_log_text(ptr, len))
-    }
-
-    pub(crate) fn log_i32<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: u32,
-    ) -> MaybeEscape {
-        hostio!(env, console_log(value))
-    }
-
-    pub(crate) fn tee_i32<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: u32,
-    ) -> Result<u32, Escape> {
-        hostio!(env, console_tee(value))
-    }
-
-    pub(crate) fn log_i64<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: u64,
-    ) -> MaybeEscape {
-        hostio!(env, console_log(value))
-    }
-
-    pub(crate) fn tee_i64<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: u64,
-    ) -> Result<u64, Escape> {
-        hostio!(env, console_tee(value))
-    }
-
-    pub(crate) fn log_f32<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: f32,
-    ) -> MaybeEscape {
-        hostio!(env, console_log(value))
-    }
-
-    pub(crate) fn tee_f32<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: f32,
-    ) -> Result<f32, Escape> {
-        hostio!(env, console_tee(value))
-    }
-
-    pub(crate) fn log_f64<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: f64,
-    ) -> MaybeEscape {
-        hostio!(env, console_log(value))
-    }
-
-    pub(crate) fn tee_f64<D: DataReader, E: EvmApi<D>>(
-        mut env: WasmEnvMut<D, E>,
-        value: f64,
-    ) -> Result<f64, Escape> {
-        hostio!(env, console_tee(value))
-    }
+pub(crate) fn console_log_text<D: DataReader, E: EvmApi<D>>(
+    mut env: WasmEnvMut<D, E>,
+    ptr: GuestPtr,
+    len: u32,
+) -> MaybeEscape {
+    hostio!(env, console_log_text(ptr, len))
 }
 
-pub(crate) mod debug {
-    use super::*;
+pub(crate) fn console_log<D: DataReader, E: EvmApi<D>, T: Into<Value>>(
+    mut env: WasmEnvMut<D, E>,
+    value: T,
+) -> MaybeEscape {
+    hostio!(env, console_log(value))
+}
 
-    pub(crate) fn null_host<D: DataReader, E: EvmApi<D>>(_: WasmEnvMut<D, E>) {}
+pub(crate) fn console_tee<D: DataReader, E: EvmApi<D>, T: Into<Value> + Copy>(
+    mut env: WasmEnvMut<D, E>,
+    value: T,
+) -> Result<T, Escape> {
+    hostio!(env, console_tee(value))
 }
+
+pub(crate) fn null_host<D: DataReader, E: EvmApi<D>>(_: WasmEnvMut<D, E>) {}
diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs
index a252b60a01..abea428167 100644
--- a/arbitrator/stylus/src/lib.rs
+++ b/arbitrator/stylus/src/lib.rs
@@ -11,7 +11,7 @@ use arbutil::{
     format::DebugBytes,
     Bytes32,
 };
-use cache::InitCache;
+use cache::{deserialize_module, InitCache, LruCacheMetrics};
 use evm_api::NativeRequestHandler;
 use eyre::ErrReport;
 use native::NativeInstance;
@@ -139,7 +139,8 @@ impl RustBytes {
 pub unsafe extern "C" fn stylus_activate(
     wasm: GoSliceData,
     page_limit: u16,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: bool,
     output: *mut RustBytes,
     codehash: *const Bytes32,
@@ -153,7 +154,15 @@ pub unsafe extern "C" fn stylus_activate(
     let codehash = &*codehash;
     let gas = &mut *gas;
 
-    let (module, info) = match native::activate(wasm, codehash, version, page_limit, debug, gas) {
+    let (module, info) = match native::activate(
+        wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas,
+    ) {
         Ok(val) => val,
         Err(err) => return output.write_err(err),
     };
@@ -300,10 +309,10 @@ pub unsafe extern "C" fn stylus_call(
     status
 }
 
-/// resize lru
+/// set lru cache capacity
 #[no_mangle]
-pub extern "C" fn stylus_cache_lru_resize(size: u32) {
-    InitCache::set_lru_size(size);
+pub extern "C" fn stylus_set_cache_lru_capacity(capacity_bytes: u64) {
+    InitCache::set_lru_capacity(capacity_bytes);
 }
 
 /// Caches an activated user program.
@@ -354,3 +363,32 @@ pub unsafe extern "C" fn stylus_drop_vec(vec: RustBytes) {
         mem::drop(vec.into_vec())
     }
 }
+
+/// Gets lru cache metrics.
+#[no_mangle]
+pub extern "C" fn stylus_get_lru_cache_metrics() -> LruCacheMetrics {
+    InitCache::get_lru_metrics()
+}
+
+/// Clears lru cache.
+/// Only used for testing purposes.
+#[no_mangle]
+pub extern "C" fn stylus_clear_lru_cache() {
+    InitCache::clear_lru_cache()
+}
+
+/// Gets lru entry size in bytes.
+/// Only used for testing purposes.
+#[no_mangle]
+pub extern "C" fn stylus_get_lru_entry_size_estimate_bytes(
+    module: GoSliceData,
+    version: u16,
+    debug: bool,
+) -> u64 {
+    match deserialize_module(module.slice(), version, debug) {
+        Err(error) => panic!("tried to get invalid asm!: {error}"),
+        Ok((_, _, lru_entry_size_estimate_bytes)) => {
+            lru_entry_size_estimate_bytes.try_into().unwrap()
+        }
+    }
+}
diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs
index 7a82314fbc..516c6602e7 100644
--- a/arbitrator/stylus/src/native.rs
+++ b/arbitrator/stylus/src/native.rs
@@ -33,7 +33,7 @@ use std::{
     ops::{Deref, DerefMut},
 };
 use wasmer::{
-    AsStoreMut, Function, FunctionEnv, Imports, Instance, Memory, Module, Pages, Store, Target,
+    imports, AsStoreMut, Function, FunctionEnv, Instance, Memory, Module, Pages, Store, Target,
     TypedFunction, Value, WasmTypeList,
 };
 use wasmer_vm::VMExtern;
@@ -151,58 +151,68 @@ impl<D: DataReader, E: EvmApi<D>> NativeInstance<D, E> {
     fn from_module(module: Module, mut store: Store, env: WasmEnv<D, E>) -> Result<Self> {
         let debug_funcs = env.compile.debug.debug_funcs;
         let func_env = FunctionEnv::new(&mut store, env);
-        let mut imports = Imports::new();
         macro_rules! func {
-            ($rust_mod:path, $func:ident) => {{
-                use $rust_mod as rust_mod;
-                Function::new_typed_with_env(&mut store, &func_env, rust_mod::$func)
-            }};
-        }
-        macro_rules! define_imports {
-            ($($wasm_mod:literal => $rust_mod:path { $( $import:ident ),* $(,)? },)* $(,)?) => {
-                $(
-                    $(
-                        define_imports!(@@imports $wasm_mod, func!($rust_mod, $import), $import, "arbitrator_forward__");
-                    )*
-                )*
-            };
-            (@@imports $wasm_mod:literal, $func:expr, $import:ident, $($p:expr),*) => {
-                define_imports!(@imports $wasm_mod, $func, $import, $($p),*, "");
-            };
-            (@imports $wasm_mod:literal, $func:expr, $import:ident, $($p:expr),*) => {
-                $(
-                    imports.define($wasm_mod, concat!($p, stringify!($import)), $func);
-                )*
+            ($func:expr) => {
+                Function::new_typed_with_env(&mut store, &func_env, $func)
             };
         }
-        define_imports!(
-            "vm_hooks" => host {
-                read_args, write_result, exit_early,
-                storage_load_bytes32, storage_cache_bytes32, storage_flush_cache, transient_load_bytes32, transient_store_bytes32,
-                call_contract, delegate_call_contract, static_call_contract, create1, create2, read_return_data, return_data_size,
-                emit_log,
-                account_balance, account_code, account_codehash, account_code_size,
-                evm_gas_left, evm_ink_left,
-                block_basefee, chainid, block_coinbase, block_gas_limit, block_number, block_timestamp,
-                contract_address,
-                math_div, math_mod, math_pow, math_add_mod, math_mul_mod,
-                msg_reentrant, msg_sender, msg_value,
-                tx_gas_price, tx_ink_price, tx_origin,
-                pay_for_memory_grow,
-                native_keccak256,
+        let mut imports = imports! {
+            "vm_hooks" => {
+                "read_args" => func!(host::read_args),
+                "write_result" => func!(host::write_result),
+                "exit_early" => func!(host::exit_early),
+                "storage_load_bytes32" => func!(host::storage_load_bytes32),
+                "storage_cache_bytes32" => func!(host::storage_cache_bytes32),
+                "storage_flush_cache" => func!(host::storage_flush_cache),
+                "transient_load_bytes32" => func!(host::transient_load_bytes32),
+                "transient_store_bytes32" => func!(host::transient_store_bytes32),
+                "call_contract" => func!(host::call_contract),
+                "delegate_call_contract" => func!(host::delegate_call_contract),
+                "static_call_contract" => func!(host::static_call_contract),
+                "create1" => func!(host::create1),
+                "create2" => func!(host::create2),
+                "read_return_data" => func!(host::read_return_data),
+                "return_data_size" => func!(host::return_data_size),
+                "emit_log" => func!(host::emit_log),
+                "account_balance" => func!(host::account_balance),
+                "account_code" => func!(host::account_code),
+                "account_codehash" => func!(host::account_codehash),
+                "account_code_size" => func!(host::account_code_size),
+                "evm_gas_left" => func!(host::evm_gas_left),
+                "evm_ink_left" => func!(host::evm_ink_left),
+                "block_basefee" => func!(host::block_basefee),
+                "chainid" => func!(host::chainid),
+                "block_coinbase" => func!(host::block_coinbase),
+                "block_gas_limit" => func!(host::block_gas_limit),
+                "block_number" => func!(host::block_number),
+                "block_timestamp" => func!(host::block_timestamp),
+                "contract_address" => func!(host::contract_address),
+                "math_div" => func!(host::math_div),
+                "math_mod" => func!(host::math_mod),
+                "math_pow" => func!(host::math_pow),
+                "math_add_mod" => func!(host::math_add_mod),
+                "math_mul_mod" => func!(host::math_mul_mod),
+                "msg_reentrant" => func!(host::msg_reentrant),
+                "msg_sender" => func!(host::msg_sender),
+                "msg_value" => func!(host::msg_value),
+                "tx_gas_price" => func!(host::tx_gas_price),
+                "tx_ink_price" => func!(host::tx_ink_price),
+                "tx_origin" => func!(host::tx_origin),
+                "pay_for_memory_grow" => func!(host::pay_for_memory_grow),
+                "native_keccak256" => func!(host::native_keccak256),
             },
-        );
+        };
         if debug_funcs {
-            define_imports!(
-                "console" => host::console {
-                    log_txt,
-                    log_i32, log_i64, log_f32, log_f64,
-                    tee_i32, tee_i64, tee_f32, tee_f64,
-                },
-                "debug" => host::debug {
-                    null_host,
-                },
-            );
+            imports.define("console", "log_txt", func!(host::console_log_text));
+            imports.define("console", "log_i32", func!(host::console_log::<D, E, u32>));
+            imports.define("console", "log_i64", func!(host::console_log::<D, E, u64>));
+            imports.define("console", "log_f32", func!(host::console_log::<D, E, f32>));
+            imports.define("console", "log_f64", func!(host::console_log::<D, E, f64>));
+            imports.define("console", "tee_i32", func!(host::console_tee::<D, E, u32>));
+            imports.define("console", "tee_i64", func!(host::console_tee::<D, E, u64>));
+            imports.define("console", "tee_f32", func!(host::console_tee::<D, E, f32>));
+            imports.define("console", "tee_f64", func!(host::console_tee::<D, E, f64>));
+            imports.define("debug", "null_host", func!(host::null_host));
         }
         let instance = Instance::new(&mut store, &module, &imports)?;
         let exports = &instance.exports;
@@ -341,8 +351,86 @@ impl<D: DataReader, E: EvmApi<D>> StartlessMachine for NativeInstance<D, E> {
 }
 
 pub fn module(wasm: &[u8], compile: CompileConfig, target: Target) -> Result<Vec<u8>> {
-    let store = compile.store(target);
+    let mut store = compile.store(target);
     let module = Module::new(&store, wasm)?;
+    macro_rules! stub {
+        (u8 <- $($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> u8 { panic!("incomplete import") })
+        };
+        (u32 <- $($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> u32 { panic!("incomplete import") })
+        };
+        (u64 <- $($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> u64 { panic!("incomplete import") })
+        };
+        (f32 <- $($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> f32 { panic!("incomplete import") })
+        };
+        (f64 <- $($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> f64 { panic!("incomplete import") })
+        };
+        ($($types:tt)+) => {
+            Function::new_typed(&mut store, $($types)+ -> () { panic!("incomplete import") })
+        };
+    }
+    let mut imports = imports! {
+        "vm_hooks" => {
+            "read_args" => stub!(|_: u32|),
+            "write_result" => stub!(|_: u32, _: u32|),
+            "exit_early" => stub!(|_: u32|),
+            "storage_load_bytes32" => stub!(|_: u32, _: u32|),
+            "storage_cache_bytes32" => stub!(|_: u32, _: u32|),
+            "storage_flush_cache" => stub!(|_: u32|),
+            "transient_load_bytes32" => stub!(|_: u32, _: u32|),
+            "transient_store_bytes32" => stub!(|_: u32, _: u32|),
+            "call_contract" => stub!(u8 <- |_: u32, _: u32, _: u32, _: u32, _: u64, _: u32|),
+            "delegate_call_contract" => stub!(u8 <- |_: u32, _: u32, _: u32, _: u64, _: u32|),
+            "static_call_contract" => stub!(u8 <- |_: u32, _: u32, _: u32, _: u64, _: u32|),
+            "create1" => stub!(|_: u32, _: u32, _: u32, _: u32, _: u32|),
+            "create2" => stub!(|_: u32, _: u32, _: u32, _: u32, _: u32, _: u32|),
+            "read_return_data" => stub!(u32 <- |_: u32, _: u32, _: u32|),
+            "return_data_size" => stub!(u32 <- ||),
+            "emit_log" => stub!(|_: u32, _: u32, _: u32|),
+            "account_balance" => stub!(|_: u32, _: u32|),
+            "account_code" => stub!(u32 <- |_: u32, _: u32, _: u32, _: u32|),
+            "account_codehash" => stub!(|_: u32, _: u32|),
+            "account_code_size" => stub!(u32 <- |_: u32|),
+            "evm_gas_left" => stub!(u64 <- ||),
+            "evm_ink_left" => stub!(u64 <- ||),
+            "block_basefee" => stub!(|_: u32|),
+            "chainid" => stub!(u64 <- ||),
+            "block_coinbase" => stub!(|_: u32|),
+            "block_gas_limit" => stub!(u64 <- ||),
+            "block_number" => stub!(u64 <- ||),
+            "block_timestamp" => stub!(u64 <- ||),
+            "contract_address" => stub!(|_: u32|),
+            "math_div" => stub!(|_: u32, _: u32|),
+            "math_mod" => stub!(|_: u32, _: u32|),
+            "math_pow" => stub!(|_: u32, _: u32|),
+            "math_add_mod" => stub!(|_: u32, _: u32, _: u32|),
+            "math_mul_mod" => stub!(|_: u32, _: u32, _: u32|),
+            "msg_reentrant" => stub!(u32 <- ||),
+            "msg_sender" => stub!(|_: u32|),
+            "msg_value" => stub!(|_: u32|),
+            "tx_gas_price" => stub!(|_: u32|),
+            "tx_ink_price" => stub!(u32 <- ||),
+            "tx_origin" => stub!(|_: u32|),
+            "pay_for_memory_grow" => stub!(|_: u16|),
+            "native_keccak256" => stub!(|_: u32, _: u32, _: u32|),
+        },
+    };
+    if compile.debug.debug_funcs {
+        imports.define("console", "log_txt", stub!(|_: u32, _: u32|));
+        imports.define("console", "log_i32", stub!(|_: u32|));
+        imports.define("console", "log_i64", stub!(|_: u64|));
+        imports.define("console", "log_f32", stub!(|_: f32|));
+        imports.define("console", "log_f64", stub!(|_: f64|));
+        imports.define("console", "tee_i32", stub!(u32 <- |_: u32|));
+        imports.define("console", "tee_i64", stub!(u64 <- |_: u64|));
+        imports.define("console", "tee_f32", stub!(f32 <- |_: f32|));
+        imports.define("console", "tee_f64", stub!(f64 <- |_: f64|));
+        imports.define("debug", "null_host", stub!(||));
+    }
 
     let module = module.serialize()?;
     Ok(module.to_vec())
@@ -351,13 +439,21 @@ pub fn module(wasm: &[u8], compile: CompileConfig, target: Target) -> Result<Vec
 pub fn activate(
     wasm: &[u8],
     codehash: &Bytes32,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     page_limit: u16,
     debug: bool,
     gas: &mut u64,
 ) -> Result<(ProverModule, StylusData)> {
-    let (module, stylus_data) =
-        ProverModule::activate(wasm, codehash, version, page_limit, debug, gas)?;
+    let (module, stylus_data) = ProverModule::activate(
+        wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas,
+    )?;
 
     Ok((module, stylus_data))
 }
diff --git a/arbitrator/stylus/src/test/api.rs b/arbitrator/stylus/src/test/api.rs
index 5d9f625e5e..66d600a6f7 100644
--- a/arbitrator/stylus/src/test/api.rs
+++ b/arbitrator/stylus/src/test/api.rs
@@ -68,7 +68,7 @@ impl TestEvmApi {
 }
 
 impl EvmApi<VecReader> for TestEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let storage = &mut self.storage.lock();
         let storage = storage.get_mut(&self.program).unwrap();
         let value = storage.get(&key).cloned().unwrap_or_default();
diff --git a/arbitrator/stylus/src/test/native.rs b/arbitrator/stylus/src/test/native.rs
index 503e5875fe..9669932a03 100644
--- a/arbitrator/stylus/src/test/native.rs
+++ b/arbitrator/stylus/src/test/native.rs
@@ -381,7 +381,7 @@ fn test_storage() -> Result<()> {
 
     let (mut native, mut evm) = TestInstance::new_with_evm(filename, &compile, config)?;
     run_native(&mut native, &store_args, ink)?;
-    assert_eq!(evm.get_bytes32(key.into()).0, Bytes32(value));
+    assert_eq!(evm.get_bytes32(key.into(), 0).0, Bytes32(value));
     assert_eq!(run_native(&mut native, &load_args, ink)?, value);
 
     let mut machine = Machine::from_user_path(Path::new(filename), &compile)?;
@@ -465,7 +465,7 @@ fn test_calls() -> Result<()> {
     run_native(&mut native, &args, ink)?;
 
     for (key, value) in slots {
-        assert_eq!(evm.get_bytes32(key).0, value);
+        assert_eq!(evm.get_bytes32(key, 0).0, value);
     }
     Ok(())
 }
diff --git a/arbitrator/stylus/tests/erc20/Cargo.lock b/arbitrator/stylus/tests/erc20/Cargo.lock
index c3e215978d..f5e1e0b15e 100644
--- a/arbitrator/stylus/tests/erc20/Cargo.lock
+++ b/arbitrator/stylus/tests/erc20/Cargo.lock
@@ -575,9 +575,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.37.23"
+version = "0.37.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
+checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
 dependencies = [
  "bitflags",
  "errno",
diff --git a/arbitrator/stylus/tests/write-result-len.wat b/arbitrator/stylus/tests/write-result-len.wat
new file mode 100644
index 0000000000..4c9ad35087
--- /dev/null
+++ b/arbitrator/stylus/tests/write-result-len.wat
@@ -0,0 +1,24 @@
+;; Copyright 2024, Offchain Labs, Inc.
+;; For license information, see https://github.com/nitro/blob/master/LICENSE
+
+(module
+    (import "vm_hooks" "read_args"    (func $read_args    (param i32)))
+    (import "vm_hooks" "write_result" (func $write_result (param i32 i32)))
+    (memory (export "memory") 2 2)
+    (func $main (export "user_entrypoint") (param $args_len i32) (result i32)
+        (local $len i32)
+
+        ;; write args to 0x0
+        (call $read_args (i32.const 0))
+
+        ;; treat first 4 bytes as size to write
+        (i32.load (i32.const 0))
+        local.set $len
+
+        ;; call write
+        (call $write_result (i32.const 0) (local.get $len))
+
+        ;; return success
+        i32.const 0
+    )
+)
diff --git a/arbitrator/wasm-libraries/Cargo.lock b/arbitrator/wasm-libraries/Cargo.lock
index 7620ff538b..a5a066e5c9 100644
--- a/arbitrator/wasm-libraries/Cargo.lock
+++ b/arbitrator/wasm-libraries/Cargo.lock
@@ -31,6 +31,21 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -91,6 +106,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -203,6 +224,15 @@ dependencies = [
  "rand_pcg",
 ]
 
+[[package]]
+name = "cc"
+version = "1.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9540e661f81799159abee814118cc139a2004b3a3aa3ea37724a1b66530b90e0"
+dependencies = [
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -215,6 +245,19 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-targets",
+]
+
 [[package]]
 name = "clap"
 version = "2.34.0"
@@ -236,6 +279,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -261,38 +310,14 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "darling"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
-dependencies = [
- "darling_core 0.13.4",
- "darling_macro 0.13.4",
-]
-
 [[package]]
 name = "darling"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.10",
- "darling_macro 0.20.10",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
@@ -305,29 +330,29 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
+ "strsim 0.11.1",
  "syn 2.0.72",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.13.4"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.13.4",
+ "darling_core",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.72",
 ]
 
 [[package]]
-name = "darling_macro"
-version = "0.20.10"
+name = "deranged"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
- "darling_core 0.20.10",
- "quote",
- "syn 2.0.72",
+ "powerfmt",
+ "serde",
 ]
 
 [[package]]
@@ -434,7 +459,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59c3b24c345d8c314966bdc1832f6c2635bfcce8e7cf363bd115987bba2ee242"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -548,6 +573,29 @@ dependencies = [
  "caller-env",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -568,6 +616,7 @@ checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
+ "serde",
 ]
 
 [[package]]
@@ -578,6 +627,7 @@ checksum = "de3fc2e30ba82dd1b3911c8de1ffc143c74a914a14e99514d7637e3099df5ea0"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.5",
+ "serde",
 ]
 
 [[package]]
@@ -595,6 +645,15 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "js-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "keccak"
 version = "0.1.5"
@@ -632,6 +691,12 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
 [[package]]
 name = "lru"
 version = "0.12.4"
@@ -719,6 +784,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-derive"
 version = "0.4.2"
@@ -832,6 +903,12 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.1.0"
@@ -1115,24 +1192,32 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "1.14.0"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff"
+checksum = "69cecfa94848272156ea67b2b1a53f20fc7bc638c4a46d2f8abde08f05f4b857"
 dependencies = [
+ "base64",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.3.0",
  "serde",
+ "serde_derive",
+ "serde_json",
  "serde_with_macros",
+ "time",
 ]
 
 [[package]]
 name = "serde_with_macros"
-version = "1.5.2"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082"
+checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350"
 dependencies = [
- "darling 0.13.4",
+ "darling",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.72",
 ]
 
 [[package]]
@@ -1181,6 +1266,12 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "simdutf8"
 version = "0.1.4"
@@ -1216,9 +1307,9 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "structopt"
@@ -1307,6 +1398,37 @@ dependencies = [
  "syn 2.0.72",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -1445,6 +1567,61 @@ dependencies = [
  "wee_alloc",
 ]
 
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+dependencies = [
+ "cfg-if 1.0.0",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+
 [[package]]
 name = "wasm-encoder"
 version = "0.215.0"
@@ -1535,6 +1712,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
diff --git a/arbitrator/wasm-libraries/forward/src/main.rs b/arbitrator/wasm-libraries/forward/src/main.rs
index 05a949e8aa..f978a8723b 100644
--- a/arbitrator/wasm-libraries/forward/src/main.rs
+++ b/arbitrator/wasm-libraries/forward/src/main.rs
@@ -191,7 +191,8 @@ fn forward_stub(file: &mut File) -> Result<()> {
         "{s};; allows user_host to request a trap\n\
         {s}(global $trap (mut i32) (i32.const 0))\n\
         {s}(func $check unreachable)\n\
-        {s}(func (export \"forward__set_trap\") unreachable)"
+        {s};; stub for the forward__set_trap function\n\
+        {s}(func $forward__set_trap unreachable)"
     );
 
     wln!("{s};; user linkage");
diff --git a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
index 37af85c382..12a6bdbed2 100644
--- a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
+++ b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
@@ -8,7 +8,7 @@ use arbutil::{
         api::{DataReader, EvmApi},
         storage::StorageCache,
         user::UserOutcomeKind,
-        EvmData,
+        EvmData, ARBOS_VERSION_STYLUS_CHARGING_FIXES,
     },
     pricing::{self, EVM_API_INK, HOSTIO_INK, PTR_INK},
     Bytes20, Bytes32,
@@ -143,11 +143,20 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     /// [`SLOAD`]: https://www.evm.codes/#54
     fn storage_load_bytes32(&mut self, key: GuestPtr, dest: GuestPtr) -> Result<(), Self::Err> {
         self.buy_ink(HOSTIO_INK + 2 * PTR_INK)?;
-        self.require_gas(evm::COLD_SLOAD_GAS + EVM_API_INK + StorageCache::REQUIRED_ACCESS_GAS)?; // cache-miss case
+        let arbos_version = self.evm_data().arbos_version;
 
+        // require for cache-miss case, preserve wrong behavior for old arbos
+        let evm_api_gas_to_use = if arbos_version < ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            EVM_API_INK
+        } else {
+            self.pricing().ink_to_gas(EVM_API_INK)
+        };
+        self.require_gas(
+            evm::COLD_SLOAD_GAS + StorageCache::REQUIRED_ACCESS_GAS + evm_api_gas_to_use,
+        )?;
         let key = self.read_bytes32(key)?;
 
-        let (value, gas_cost) = self.evm_api().get_bytes32(key);
+        let (value, gas_cost) = self.evm_api().get_bytes32(key, evm_api_gas_to_use);
         self.buy_gas(gas_cost)?;
         self.write_bytes32(dest, value)?;
         trace!("storage_load_bytes32", self, key, value)
@@ -185,7 +194,10 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         self.require_gas(evm::SSTORE_SENTRY_GAS)?; // see operations_acl_arbitrum.go
 
         let gas_left = self.gas_left()?;
-        self.evm_api().flush_storage_cache(clear, gas_left)?;
+        let gas_cost = self.evm_api().flush_storage_cache(clear, gas_left)?;
+        if self.evm_data().arbos_version >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            self.buy_gas(gas_cost)?;
+        }
         trace!("storage_flush_cache", self, [be!(clear as u8)], &[])
     }
 
diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs
index 428611167d..f4c402fd97 100644
--- a/arbitrator/wasm-libraries/user-host/src/link.rs
+++ b/arbitrator/wasm-libraries/user-host/src/link.rs
@@ -37,14 +37,15 @@ struct MemoryLeaf([u8; 32]);
 ///
 /// pages_ptr: starts pointing to max allowed pages, returns number of pages used
 #[no_mangle]
-pub unsafe extern "C" fn programs__activate(
+pub unsafe extern "C" fn programs__activate_v2(
     wasm_ptr: GuestPtr,
     wasm_size: usize,
     pages_ptr: GuestPtr,
     asm_estimate_ptr: GuestPtr,
     init_cost_ptr: GuestPtr,
     cached_init_cost_ptr: GuestPtr,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: u32,
     codehash: GuestPtr,
     module_hash_ptr: GuestPtr,
@@ -58,7 +59,15 @@ pub unsafe extern "C" fn programs__activate(
 
     let page_limit = STATIC_MEM.read_u16(pages_ptr);
     let gas_left = &mut STATIC_MEM.read_u64(gas_ptr);
-    match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) {
+    match Module::activate(
+        &wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas_left,
+    ) {
         Ok((module, data)) => {
             STATIC_MEM.write_u64(gas_ptr, *gas_left);
             STATIC_MEM.write_u16(pages_ptr, data.footprint);
@@ -242,7 +251,8 @@ pub unsafe extern "C" fn programs__create_stylus_config(
 /// Creates an `EvmData` handler from its component parts.
 ///
 #[no_mangle]
-pub unsafe extern "C" fn programs__create_evm_data(
+pub unsafe extern "C" fn programs__create_evm_data_v2(
+    arbos_version: u64,
     block_basefee_ptr: GuestPtr,
     chainid: u64,
     block_coinbase_ptr: GuestPtr,
@@ -259,6 +269,7 @@ pub unsafe extern "C" fn programs__create_evm_data(
     reentrant: u32,
 ) -> u64 {
     let evm_data = EvmData {
+        arbos_version,
         block_basefee: read_bytes32(block_basefee_ptr),
         cached: cached != 0,
         chainid,
diff --git a/arbitrator/wasm-libraries/user-test/src/program.rs b/arbitrator/wasm-libraries/user-test/src/program.rs
index c56ea52ad0..85b522ee74 100644
--- a/arbitrator/wasm-libraries/user-test/src/program.rs
+++ b/arbitrator/wasm-libraries/user-test/src/program.rs
@@ -102,7 +102,7 @@ impl Program {
 pub struct MockEvmApi;
 
 impl EvmApi<VecReader> for MockEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let value = KEYS.lock().get(&key).cloned().unwrap_or_default();
         (value, 2100) // pretend worst case
     }
diff --git a/arbnode/api.go b/arbnode/api.go
index 228ad51cf8..2dabd41bff 100644
--- a/arbnode/api.go
+++ b/arbnode/api.go
@@ -7,9 +7,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/staker"
 	"github.com/offchainlabs/nitro/validator"
+	"github.com/offchainlabs/nitro/validator/server_api"
 )
 
 type BlockValidatorAPI struct {
@@ -54,3 +56,8 @@ func (a *BlockValidatorDebugAPI) ValidateMessageNumber(
 	result.Valid = valid
 	return result, err
 }
+
+func (a *BlockValidatorDebugAPI) ValidationInputsAt(ctx context.Context, msgNum hexutil.Uint64, target ethdb.WasmTarget,
+) (server_api.InputJSON, error) {
+	return a.val.ValidationInputsAt(ctx, arbutil.MessageIndex(msgNum), target)
+}
diff --git a/arbnode/inbox_test.go b/arbnode/inbox_test.go
index d579b7c278..e588ef399b 100644
--- a/arbnode/inbox_test.go
+++ b/arbnode/inbox_test.go
@@ -74,7 +74,7 @@ func NewTransactionStreamerForTest(t *testing.T, ownerAddress common.Address) (*
 	}
 	stylusTargetConfig := &gethexec.DefaultStylusTargetConfig
 	Require(t, stylusTargetConfig.Validate()) // pre-processes config (i.a. parses wasmTargets)
-	if err := execEngine.Initialize(gethexec.DefaultCachingConfig.StylusLRUCache, stylusTargetConfig); err != nil {
+	if err := execEngine.Initialize(gethexec.DefaultCachingConfig.StylusLRUCacheCapacity, &gethexec.DefaultStylusTargetConfig); err != nil {
 		Fail(t, err)
 	}
 	execSeq := &execClientWrapper{execEngine, t}
diff --git a/arbnode/seq_coordinator.go b/arbnode/seq_coordinator.go
index a582b64ffa..176ace114b 100644
--- a/arbnode/seq_coordinator.go
+++ b/arbnode/seq_coordinator.go
@@ -491,7 +491,7 @@ func (c *SeqCoordinator) updateWithLockout(ctx context.Context, nextChosen strin
 		// Before proceeding, first try deleting finalized messages from redis and setting the finalizedMsgCount key
 		finalized, err := c.sync.GetFinalizedMsgCount(ctx)
 		if err != nil {
-			log.Warn("Error getting finalizedMessageCount from syncMonitor: %w", err)
+			log.Warn("Error getting finalizedMessageCount from syncMonitor", "err", err)
 		} else if finalized == 0 {
 			log.Warn("SyncMonitor returned zero finalizedMessageCount")
 		} else if err := c.deleteFinalizedMsgsFromRedis(ctx, finalized); err != nil {
diff --git a/arbnode/transaction_streamer.go b/arbnode/transaction_streamer.go
index 24a0564b97..38b1c003db 100644
--- a/arbnode/transaction_streamer.go
+++ b/arbnode/transaction_streamer.go
@@ -1140,7 +1140,7 @@ func (s *TransactionStreamer) storeResult(
 
 // exposed for testing
 // return value: true if should be called again immediately
-func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context, exec execution.ExecutionSequencer) bool {
+func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context) bool {
 	if ctx.Err() != nil {
 		return false
 	}
@@ -1212,7 +1212,7 @@ func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context, exec execution
 }
 
 func (s *TransactionStreamer) executeMessages(ctx context.Context, ignored struct{}) time.Duration {
-	if s.ExecuteNextMsg(ctx, s.exec) {
+	if s.ExecuteNextMsg(ctx) {
 		return 0
 	}
 	return s.config().ExecuteMessageLoopDelay
diff --git a/arbos/arbosState/arbosstate.go b/arbos/arbosState/arbosstate.go
index 91c2207aae..f53d9c892a 100644
--- a/arbos/arbosState/arbosstate.go
+++ b/arbos/arbosState/arbosstate.go
@@ -41,28 +41,29 @@ import (
 // persisted beyond the end of the test.)
 
 type ArbosState struct {
-	arbosVersion                  uint64                      // version of the ArbOS storage format and semantics
-	maxArbosVersionSupported      uint64                      // maximum ArbOS version supported by this code
-	maxDebugArbosVersionSupported uint64                      // maximum ArbOS version supported by this code in debug mode
-	upgradeVersion                storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade
-	upgradeTimestamp              storage.StorageBackedUint64 // when to do the planned upgrade
-	networkFeeAccount             storage.StorageBackedAddress
-	l1PricingState                *l1pricing.L1PricingState
-	l2PricingState                *l2pricing.L2PricingState
-	retryableState                *retryables.RetryableState
-	addressTable                  *addressTable.AddressTable
-	chainOwners                   *addressSet.AddressSet
-	sendMerkle                    *merkleAccumulator.MerkleAccumulator
-	programs                      *programs.Programs
-	blockhashes                   *blockhash.Blockhashes
-	chainId                       storage.StorageBackedBigInt
-	chainConfig                   storage.StorageBackedBytes
-	genesisBlockNum               storage.StorageBackedUint64
-	infraFeeAccount               storage.StorageBackedAddress
-	brotliCompressionLevel        storage.StorageBackedUint64 // brotli compression level used for pricing
-	backingStorage                *storage.Storage
-	Burner                        burn.Burner
-}
+	arbosVersion           uint64                      // version of the ArbOS storage format and semantics
+	upgradeVersion         storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade
+	upgradeTimestamp       storage.StorageBackedUint64 // when to do the planned upgrade
+	networkFeeAccount      storage.StorageBackedAddress
+	l1PricingState         *l1pricing.L1PricingState
+	l2PricingState         *l2pricing.L2PricingState
+	retryableState         *retryables.RetryableState
+	addressTable           *addressTable.AddressTable
+	chainOwners            *addressSet.AddressSet
+	sendMerkle             *merkleAccumulator.MerkleAccumulator
+	programs               *programs.Programs
+	blockhashes            *blockhash.Blockhashes
+	chainId                storage.StorageBackedBigInt
+	chainConfig            storage.StorageBackedBytes
+	genesisBlockNum        storage.StorageBackedUint64
+	infraFeeAccount        storage.StorageBackedAddress
+	brotliCompressionLevel storage.StorageBackedUint64 // brotli compression level used for pricing
+	backingStorage         *storage.Storage
+	Burner                 burn.Burner
+}
+
+const MaxArbosVersionSupported uint64 = params.ArbosVersion_StylusChargingFixes
+const MaxDebugArbosVersionSupported uint64 = params.ArbosVersion_StylusChargingFixes
 
 var ErrUninitializedArbOS = errors.New("ArbOS uninitialized")
 var ErrAlreadyInitialized = errors.New("ArbOS is already initialized")
@@ -78,8 +79,6 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 	}
 	return &ArbosState{
 		arbosVersion,
-		31,
-		31,
 		backingStorage.OpenStorageBackedUint64(uint64(upgradeVersionOffset)),
 		backingStorage.OpenStorageBackedUint64(uint64(upgradeTimestampOffset)),
 		backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)),
@@ -332,6 +331,9 @@ func (state *ArbosState) UpgradeArbosVersion(
 			ensure(params.UpgradeToVersion(2))
 			ensure(params.Save())
 
+		case 32:
+			// no change state needed
+
 		default:
 			return fmt.Errorf(
 				"the chain is upgrading to unsupported ArbOS version %v, %w",
@@ -416,14 +418,6 @@ func (state *ArbosState) RetryableState() *retryables.RetryableState {
 	return state.retryableState
 }
 
-func (state *ArbosState) MaxArbosVersionSupported() uint64 {
-	return state.maxArbosVersionSupported
-}
-
-func (state *ArbosState) MaxDebugArbosVersionSupported() uint64 {
-	return state.maxDebugArbosVersionSupported
-}
-
 func (state *ArbosState) L1PricingState() *l1pricing.L1PricingState {
 	return state.l1PricingState
 }
diff --git a/arbos/arbostypes/incomingmessage.go b/arbos/arbostypes/incomingmessage.go
index 04ce8ebe2e..c4c2dc037b 100644
--- a/arbos/arbostypes/incomingmessage.go
+++ b/arbos/arbostypes/incomingmessage.go
@@ -182,6 +182,17 @@ func (msg *L1IncomingMessage) FillInBatchGasCost(batchFetcher FallibleBatchFetch
 	return nil
 }
 
+func (msg *L1IncomingMessage) PastBatchesRequired() ([]uint64, error) {
+	if msg.Header.Kind != L1MessageType_BatchPostingReport {
+		return nil, nil
+	}
+	_, _, _, batchNum, _, _, err := ParseBatchPostingReportMessageFields(bytes.NewReader(msg.L2msg))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse batch posting report: %w", err)
+	}
+	return []uint64{batchNum}, nil
+}
+
 func ParseIncomingL1Message(rd io.Reader, batchFetcher FallibleBatchFetcher) (*L1IncomingMessage, error) {
 	var kindBuf [1]byte
 	_, err := rd.Read(kindBuf[:])
diff --git a/arbos/programs/api.go b/arbos/programs/api.go
index 504289322f..3e59031b2d 100644
--- a/arbos/programs/api.go
+++ b/arbos/programs/api.go
@@ -400,9 +400,9 @@ func newApiClosures(
 			}
 			startInk := takeU64()
 			endInk := takeU64()
-			nameLen := takeU16()
-			argsLen := takeU16()
-			outsLen := takeU16()
+			nameLen := takeU32()
+			argsLen := takeU32()
+			outsLen := takeU32()
 			name := string(takeFixed(int(nameLen)))
 			args := takeFixed(int(argsLen))
 			outs := takeFixed(int(outsLen))
diff --git a/arbos/programs/native.go b/arbos/programs/native.go
index 377e25a31e..5fbc512211 100644
--- a/arbos/programs/native.go
+++ b/arbos/programs/native.go
@@ -7,7 +7,7 @@
 package programs
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 
@@ -29,6 +29,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/offchainlabs/nitro/arbos/burn"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -45,17 +46,26 @@ type bytes32 = C.Bytes32
 type rustBytes = C.RustBytes
 type rustSlice = C.RustSlice
 
+var (
+	stylusLRUCacheSizeBytesGauge        = metrics.NewRegisteredGauge("arb/arbos/stylus/cache/lru/size_bytes", nil)
+	stylusLRUCacheSizeCountGauge        = metrics.NewRegisteredGauge("arb/arbos/stylus/cache/lru/count", nil)
+	stylusLRUCacheSizeHitsCounter       = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/hits", nil)
+	stylusLRUCacheSizeMissesCounter     = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/misses", nil)
+	stylusLRUCacheSizeDoesNotFitCounter = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/does_not_fit", nil)
+)
+
 func activateProgram(
 	db vm.StateDB,
 	program common.Address,
 	codehash common.Hash,
 	wasm []byte,
 	page_limit uint16,
-	version uint16,
+	stylusVersion uint16,
+	arbosVersionForGas uint64,
 	debug bool,
 	burner burn.Burner,
 ) (*activationInfo, error) {
-	info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, version, debug, burner.GasLeft())
+	info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft())
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +79,8 @@ func activateProgramInternal(
 	codehash common.Hash,
 	wasm []byte,
 	page_limit uint16,
-	version uint16,
+	stylusVersion uint16,
+	arbosVersionForGas uint64,
 	debug bool,
 	gasLeft *uint64,
 ) (*activationInfo, map[ethdb.WasmTarget][]byte, error) {
@@ -81,7 +92,8 @@ func activateProgramInternal(
 	status_mod := userStatus(C.stylus_activate(
 		goSlice(wasm),
 		u16(page_limit),
-		u16(version),
+		u16(stylusVersion),
+		u64(arbosVersionForGas),
 		cbool(debug),
 		output,
 		&codeHash,
@@ -100,6 +112,7 @@ func activateProgramInternal(
 		}
 		return nil, nil, err
 	}
+	hash := moduleHash.toHash()
 	targets := db.Database().WasmTargets()
 	type result struct {
 		target ethdb.WasmTarget
@@ -108,15 +121,15 @@ func activateProgramInternal(
 	}
 	results := make(chan result, len(targets))
 	for _, target := range targets {
+		target := target
 		if target == rawdb.TargetWavm {
 			results <- result{target, module, nil}
 		} else {
-			target := target
 			go func() {
 				output := &rustBytes{}
 				status_asm := C.stylus_compile(
 					goSlice(wasm),
-					u16(version),
+					u16(stylusVersion),
 					cbool(debug),
 					goSlice([]byte(target)),
 					output,
@@ -140,10 +153,17 @@ func activateProgramInternal(
 		}
 	}
 	if err != nil {
-		return nil, nil, fmt.Errorf("compilation failed for one or more targets: %w", err)
+		log.Error(
+			"Compilation failed for one or more targets despite activation succeeding",
+			"address", addressForLogging,
+			"codeHash", codeHash,
+			"moduleHash", hash,
+			"targets", targets,
+			"err", err,
+		)
+		panic(fmt.Sprintf("Compilation of %v failed for one or more targets despite activation succeeding: %v", addressForLogging, err))
 	}
 
-	hash := moduleHash.toHash()
 	info := &activationInfo{
 		moduleHash:    hash,
 		initGas:       uint16(stylusData.init_cost),
@@ -168,9 +188,12 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
 	}
 
-	unlimitedGas := uint64(0xffffffffffff)
+	// don't charge gas
+	zeroArbosVersion := uint64(0)
+	zeroGas := uint64(0)
+
 	// we know program is activated, so it must be in correct version and not use too much memory
-	info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, debugMode, &unlimitedGas)
+	info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
 	if err != nil {
 		log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err)
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
@@ -306,8 +329,39 @@ func init() {
 	}
 }
 
-func ResizeWasmLruCache(size uint32) {
-	C.stylus_cache_lru_resize(u32(size))
+func SetWasmLruCacheCapacity(capacityBytes uint64) {
+	C.stylus_set_cache_lru_capacity(u64(capacityBytes))
+}
+
+// exported for testing
+type WasmLruCacheMetrics struct {
+	SizeBytes uint64
+	Count     uint32
+}
+
+func GetWasmLruCacheMetrics() *WasmLruCacheMetrics {
+	metrics := C.stylus_get_lru_cache_metrics()
+
+	stylusLRUCacheSizeBytesGauge.Update(int64(metrics.size_bytes))
+	stylusLRUCacheSizeCountGauge.Update(int64(metrics.count))
+	stylusLRUCacheSizeHitsCounter.Inc(int64(metrics.hits))
+	stylusLRUCacheSizeMissesCounter.Inc(int64(metrics.misses))
+	stylusLRUCacheSizeDoesNotFitCounter.Inc(int64(metrics.does_not_fit))
+
+	return &WasmLruCacheMetrics{
+		SizeBytes: uint64(metrics.size_bytes),
+		Count:     uint32(metrics.count),
+	}
+}
+
+// Used for testing
+func ClearWasmLruCache() {
+	C.stylus_clear_lru_cache()
+}
+
+// Used for testing
+func GetLruEntrySizeEstimateBytes(module []byte, version uint16, debug bool) uint64 {
+	return uint64(C.stylus_get_lru_entry_size_estimate_bytes(goSlice(module), u16(version), cbool(debug)))
 }
 
 const DefaultTargetDescriptionArm = "arm64-linux-unknown+neon"
@@ -391,6 +445,7 @@ func (params *ProgParams) encode() C.StylusConfig {
 
 func (data *EvmData) encode() C.EvmData {
 	return C.EvmData{
+		arbos_version:    u64(data.arbosVersion),
 		block_basefee:    hashToBytes32(data.blockBasefee),
 		chainid:          u64(data.chainId),
 		block_coinbase:   addressToBytes20(data.blockCoinbase),
diff --git a/arbos/programs/native_api.go b/arbos/programs/native_api.go
index 6fbb630ef3..6cecb8ef63 100644
--- a/arbos/programs/native_api.go
+++ b/arbos/programs/native_api.go
@@ -7,7 +7,7 @@
 package programs
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 
diff --git a/arbos/programs/programs.go b/arbos/programs/programs.go
index 12102bac84..06ff4137da 100644
--- a/arbos/programs/programs.go
+++ b/arbos/programs/programs.go
@@ -82,7 +82,7 @@ func (p Programs) CacheManagers() *addressSet.AddressSet {
 	return p.cacheManagers
 }
 
-func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode core.MessageRunMode, debugMode bool) (
+func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, arbosVersion uint64, runMode core.MessageRunMode, debugMode bool) (
 	uint16, common.Hash, common.Hash, *big.Int, bool, error,
 ) {
 	statedb := evm.StateDB
@@ -116,7 +116,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 	// require the program's footprint not exceed the remaining memory budget
 	pageLimit := am.SaturatingUSub(params.PageLimit, statedb.GetStylusPagesOpen())
 
-	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, debugMode, burner)
+	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, arbosVersion, debugMode, burner)
 	if err != nil {
 		return 0, codeHash, common.Hash{}, nil, true, err
 	}
@@ -127,6 +127,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 		if err != nil {
 			return 0, codeHash, common.Hash{}, nil, true, err
 		}
+
 		evictProgram(statedb, oldModuleHash, currentVersion, debugMode, runMode, expired)
 	}
 	if err := p.moduleHashes.Set(codeHash, info.moduleHash); err != nil {
@@ -222,6 +223,7 @@ func (p Programs) CallProgram(
 	}
 
 	evmData := &EvmData{
+		arbosVersion:    evm.Context.ArbOSVersion,
 		blockBasefee:    common.BigToHash(evm.Context.BaseFee),
 		chainId:         evm.ChainConfig().ChainID.Uint64(),
 		blockCoinbase:   evm.Context.Coinbase,
@@ -517,6 +519,7 @@ func (p Programs) progParams(version uint16, debug bool, params *StylusParams) *
 }
 
 type EvmData struct {
+	arbosVersion    uint64
 	blockBasefee    common.Hash
 	chainId         uint64
 	blockCoinbase   common.Address
diff --git a/arbos/programs/testcompile.go b/arbos/programs/testcompile.go
index 1daf470620..615b0f3f72 100644
--- a/arbos/programs/testcompile.go
+++ b/arbos/programs/testcompile.go
@@ -9,7 +9,7 @@ package programs
 // This file exists because cgo isn't allowed in tests
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 
 typedef uint16_t u16;
diff --git a/arbos/programs/testconstants.go b/arbos/programs/testconstants.go
index 1ab0e6e93b..44f69a52de 100644
--- a/arbos/programs/testconstants.go
+++ b/arbos/programs/testconstants.go
@@ -9,7 +9,7 @@ package programs
 // This file exists because cgo isn't allowed in tests
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 */
 import "C"
diff --git a/arbos/programs/wasm.go b/arbos/programs/wasm.go
index f7191dca8f..12c23a724c 100644
--- a/arbos/programs/wasm.go
+++ b/arbos/programs/wasm.go
@@ -36,7 +36,7 @@ type rustConfig byte
 type rustModule byte
 type rustEvmData byte
 
-//go:wasmimport programs activate
+//go:wasmimport programs activate_v2
 func programActivate(
 	wasm_ptr unsafe.Pointer,
 	wasm_size uint32,
@@ -44,7 +44,8 @@ func programActivate(
 	asm_estimation_ptr unsafe.Pointer,
 	init_gas_ptr unsafe.Pointer,
 	cached_init_gas_ptr unsafe.Pointer,
-	version uint32,
+	stylusVersion uint32,
+	arbosVersion uint64,
 	debug uint32,
 	codehash unsafe.Pointer,
 	module_hash_ptr unsafe.Pointer,
@@ -59,7 +60,8 @@ func activateProgram(
 	codehash common.Hash,
 	wasm []byte,
 	pageLimit u16,
-	version u16,
+	stylusVersion u16,
+	arbosVersion uint64,
 	debug bool,
 	burner burn.Burner,
 ) (*activationInfo, error) {
@@ -79,7 +81,8 @@ func activateProgram(
 		unsafe.Pointer(&asmEstimate),
 		unsafe.Pointer(&initGas),
 		unsafe.Pointer(&cachedInitGas),
-		uint32(version),
+		uint32(stylusVersion),
+		arbosVersion,
 		debugMode,
 		arbutil.SliceToUnsafePointer(codehash[:]),
 		arbutil.SliceToUnsafePointer(moduleHash[:]),
@@ -151,6 +154,8 @@ func callProgram(
 	return retData, err
 }
 
+func GetWasmLruCacheMetrics() {}
+
 func CallProgramLoop(
 	moduleHash common.Hash,
 	calldata []byte,
diff --git a/arbos/programs/wasm_api.go b/arbos/programs/wasm_api.go
index d7bac056c0..a4ebc1f778 100644
--- a/arbos/programs/wasm_api.go
+++ b/arbos/programs/wasm_api.go
@@ -20,8 +20,9 @@ func createStylusConfig(version uint32, max_depth uint32, ink_price uint32, debu
 
 type evmDataHandler uint64
 
-//go:wasmimport programs create_evm_data
+//go:wasmimport programs create_evm_data_v2
 func createEvmData(
+	arbosVersion uint64,
 	blockBaseFee unsafe.Pointer,
 	chainid uint64,
 	blockCoinbase unsafe.Pointer,
@@ -45,6 +46,7 @@ func (params *ProgParams) createHandler() stylusConfigHandler {
 
 func (data *EvmData) createHandler() evmDataHandler {
 	return createEvmData(
+		data.arbosVersion,
 		arbutil.SliceToUnsafePointer(data.blockBasefee[:]),
 		data.chainId,
 		arbutil.SliceToUnsafePointer(data.blockCoinbase[:]),
diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go
index 434820dd9c..c2d1aa65b0 100644
--- a/arbos/programs/wasmstorehelper.go
+++ b/arbos/programs/wasmstorehelper.go
@@ -17,12 +17,12 @@ import (
 
 // SaveActiveProgramToWasmStore is used to save active stylus programs to wasm store during rebuilding
 func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash common.Hash, code []byte, time uint64, debugMode bool, rebuildingStartBlockTime uint64) error {
-	params, err := p.Params()
+	progParams, err := p.Params()
 	if err != nil {
 		return err
 	}
 
-	program, err := p.getActiveProgram(codeHash, time, params)
+	program, err := p.getActiveProgram(codeHash, time, progParams)
 	if err != nil {
 		// The program is not active so return early
 		log.Info("program is not active, getActiveProgram returned error, hence do not include in rebuilding", "err", err)
@@ -56,10 +56,13 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash
 		return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err)
 	}
 
-	unlimitedGas := uint64(0xffffffffffff)
+	// don't charge gas
+	zeroArbosVersion := uint64(0)
+	zeroGas := uint64(0)
+
 	// We know program is activated, so it must be in correct version and not use too much memory
 	// Empty program address is supplied because we dont have access to this during rebuilding of wasm store
-	info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, params.PageLimit, program.version, debugMode, &unlimitedGas)
+	info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
 	if err != nil {
 		log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err)
 		return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err)
diff --git a/arbos/tx_processor.go b/arbos/tx_processor.go
index b08c7c5d30..d6c35339f6 100644
--- a/arbos/tx_processor.go
+++ b/arbos/tx_processor.go
@@ -532,6 +532,20 @@ func (p *TxProcessor) EndTxHook(gasLeft uint64, success bool) {
 		refund := func(refundFrom common.Address, amount *big.Int) {
 			const errLog = "fee address doesn't have enough funds to give user refund"
 
+			logMissingRefund := func(err error) {
+				if !errors.Is(err, vm.ErrInsufficientBalance) {
+					log.Error("unexpected error refunding balance", "err", err, "feeAddress", refundFrom)
+					return
+				}
+				logLevel := log.Error
+				isContract := p.evm.StateDB.GetCodeSize(refundFrom) > 0
+				if isContract {
+					// It's expected that the balance might not still be in this address if it's a contract.
+					logLevel = log.Debug
+				}
+				logLevel(errLog, "err", err, "feeAddress", refundFrom)
+			}
+
 			// Refund funds to the fee refund address without overdrafting the L1 deposit.
 			toRefundAddr := takeFunds(maxRefund, amount)
 			err = util.TransferBalance(&refundFrom, &inner.RefundTo, toRefundAddr, p.evm, scenario, "refund")
@@ -539,13 +553,13 @@ func (p *TxProcessor) EndTxHook(gasLeft uint64, success bool) {
 				// Normally the network fee address should be holding any collected fees.
 				// However, in theory, they could've been transferred out during the redeem attempt.
 				// If the network fee address doesn't have the necessary balance, log an error and don't give a refund.
-				log.Error(errLog, "err", err, "feeAddress", refundFrom)
+				logMissingRefund(err)
 			}
 			// Any extra refund can't be given to the fee refund address if it didn't come from the L1 deposit.
 			// Instead, give the refund to the retryable from address.
 			err = util.TransferBalance(&refundFrom, &inner.From, arbmath.BigSub(amount, toRefundAddr), p.evm, scenario, "refund")
 			if err != nil {
-				log.Error(errLog, "err", err, "feeAddress", refundFrom)
+				logMissingRefund(err)
 			}
 		}
 
diff --git a/arbos/util/storage_cache.go b/arbos/util/storage_cache.go
index bf05a5824d..9573d1ffc7 100644
--- a/arbos/util/storage_cache.go
+++ b/arbos/util/storage_cache.go
@@ -5,6 +5,7 @@ package util
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"slices"
 )
 
 type storageCacheEntry struct {
@@ -67,6 +68,10 @@ func (s *storageCache) Flush() []storageCacheStores {
 			})
 		}
 	}
+	sortFunc := func(a, b storageCacheStores) int {
+		return a.Key.Cmp(b.Key)
+	}
+	slices.SortFunc(stores, sortFunc)
 	return stores
 }
 
diff --git a/arbos/util/storage_cache_test.go b/arbos/util/storage_cache_test.go
index 1cc4ea14ec..9fd452851d 100644
--- a/arbos/util/storage_cache_test.go
+++ b/arbos/util/storage_cache_test.go
@@ -4,7 +4,6 @@
 package util
 
 import (
-	"bytes"
 	"slices"
 	"testing"
 
@@ -76,7 +75,7 @@ func TestStorageCache(t *testing.T) {
 			{Key: keys[2], Value: values[2]},
 		}
 		sortFunc := func(a, b storageCacheStores) int {
-			return bytes.Compare(a.Key.Bytes(), b.Key.Bytes())
+			return a.Key.Cmp(b.Key)
 		}
 		slices.SortFunc(stores, sortFunc)
 		slices.SortFunc(expected, sortFunc)
diff --git a/cmd/chaininfo/arbitrum_chain_info.json b/cmd/chaininfo/arbitrum_chain_info.json
index 524433a7b5..f862c6dfbf 100644
--- a/cmd/chaininfo/arbitrum_chain_info.json
+++ b/cmd/chaininfo/arbitrum_chain_info.json
@@ -164,7 +164,7 @@
         "EnableArbOS": true,
         "AllowDebugPrecompiles": true,
         "DataAvailabilityCommittee": false,
-        "InitialArbOSVersion": 31,
+        "InitialArbOSVersion": 32,
         "InitialChainOwner": "0x0000000000000000000000000000000000000000",
         "GenesisBlockNum": 0
       }
@@ -196,7 +196,7 @@
         "EnableArbOS": true,
         "AllowDebugPrecompiles": true,
         "DataAvailabilityCommittee": true,
-        "InitialArbOSVersion": 31,
+        "InitialArbOSVersion": 32,
         "InitialChainOwner": "0x0000000000000000000000000000000000000000",
         "GenesisBlockNum": 0
       }
diff --git a/cmd/deploy/deploy.go b/cmd/deploy/deploy.go
index d8c0aeeac4..c70ceb1d94 100644
--- a/cmd/deploy/deploy.go
+++ b/cmd/deploy/deploy.go
@@ -61,7 +61,6 @@ func main() {
 	authorizevalidators := flag.Uint64("authorizevalidators", 0, "Number of validators to preemptively authorize")
 	txTimeout := flag.Duration("txtimeout", 10*time.Minute, "Timeout when waiting for a transaction to be included in a block")
 	prod := flag.Bool("prod", false, "Whether to configure the rollup for production or testing")
-	isUsingFeeToken := flag.Bool("isUsingFeeToken", false, "true if the chain uses custom fee token")
 	flag.Parse()
 	l1ChainId := new(big.Int).SetUint64(*l1ChainIdUint)
 	maxDataSize := new(big.Int).SetUint64(*maxDataSizeUint)
@@ -180,7 +179,7 @@ func main() {
 	defer l1Reader.StopAndWait()
 
 	nativeToken := common.HexToAddress(*nativeTokenAddressString)
-	deployedAddresses, err := deploycode.DeployOnL1(
+	deployedAddresses, err := deploycode.DeployOnParentChain(
 		ctx,
 		l1Reader,
 		l1TransactionOpts,
@@ -190,7 +189,7 @@ func main() {
 		arbnode.GenerateRollupConfig(*prod, moduleRoot, ownerAddress, &chainConfig, chainConfigJson, loserEscrowAddress),
 		nativeToken,
 		maxDataSize,
-		*isUsingFeeToken,
+		true,
 	)
 	if err != nil {
 		flag.Usage()
diff --git a/cmd/nitro/init.go b/cmd/nitro/init.go
index fec6b15559..9e3ecec747 100644
--- a/cmd/nitro/init.go
+++ b/cmd/nitro/init.go
@@ -354,12 +354,12 @@ func validateBlockChain(blockChain *core.BlockChain, chainConfig *params.ChainCo
 	}
 	// Make sure we don't allow accidentally downgrading ArbOS
 	if chainConfig.DebugMode() {
-		if currentArbosState.ArbOSVersion() > currentArbosState.MaxDebugArbosVersionSupported() {
-			return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxDebugArbosVersionSupported(), currentArbosState.ArbOSVersion())
+		if currentArbosState.ArbOSVersion() > arbosState.MaxDebugArbosVersionSupported {
+			return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", arbosState.MaxDebugArbosVersionSupported, currentArbosState.ArbOSVersion())
 		}
 	} else {
-		if currentArbosState.ArbOSVersion() > currentArbosState.MaxArbosVersionSupported() {
-			return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxArbosVersionSupported(), currentArbosState.ArbOSVersion())
+		if currentArbosState.ArbOSVersion() > arbosState.MaxArbosVersionSupported {
+			return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", arbosState.MaxArbosVersionSupported, currentArbosState.ArbOSVersion())
 		}
 
 	}
diff --git a/cmd/nitro/nitro.go b/cmd/nitro/nitro.go
index e66d99b56e..bc2155a475 100644
--- a/cmd/nitro/nitro.go
+++ b/cmd/nitro/nitro.go
@@ -249,7 +249,7 @@ func mainImpl() int {
 	// If sequencer and signing is enabled or batchposter is enabled without
 	// external signing sequencer will need a key.
 	sequencerNeedsKey := (nodeConfig.Node.Sequencer && !nodeConfig.Node.Feed.Output.DisableSigning) ||
-		(nodeConfig.Node.BatchPoster.Enable && nodeConfig.Node.BatchPoster.DataPoster.ExternalSigner.URL == "")
+		(nodeConfig.Node.BatchPoster.Enable && (nodeConfig.Node.BatchPoster.DataPoster.ExternalSigner.URL == "" || nodeConfig.Node.DataAvailability.Enable))
 	validatorNeedsKey := nodeConfig.Node.Staker.OnlyCreateWalletContract ||
 		(nodeConfig.Node.Staker.Enable && !strings.EqualFold(nodeConfig.Node.Staker.Strategy, "watchtower") && nodeConfig.Node.Staker.DataPoster.ExternalSigner.URL == "")
 
@@ -437,61 +437,9 @@ func mainImpl() int {
 
 	// Check that node is compatible with on-chain WASM module root on startup and before any ArbOS upgrades take effect to prevent divergences
 	if nodeConfig.Node.ParentChainReader.Enable && nodeConfig.Validation.Wasm.EnableWasmrootsCheck {
-		// Fetch current on-chain WASM module root
-		rollupUserLogic, err := rollupgen.NewRollupUserLogic(rollupAddrs.Rollup, l1Client)
+		err := checkWasmModuleRootCompatibility(ctx, nodeConfig.Validation.Wasm, l1Client, rollupAddrs)
 		if err != nil {
-			log.Error("failed to create rollupUserLogic", "err", err)
-			return 1
-		}
-		moduleRoot, err := rollupUserLogic.WasmModuleRoot(&bind.CallOpts{Context: ctx})
-		if err != nil {
-			log.Error("failed to get on-chain WASM module root", "err", err)
-			return 1
-		}
-		if (moduleRoot == common.Hash{}) {
-			log.Error("on-chain WASM module root is zero")
-			return 1
-		}
-		// Check if the on-chain WASM module root belongs to the set of allowed module roots
-		allowedWasmModuleRoots := nodeConfig.Validation.Wasm.AllowedWasmModuleRoots
-		if len(allowedWasmModuleRoots) > 0 {
-			moduleRootMatched := false
-			for _, root := range allowedWasmModuleRoots {
-				bytes, err := hex.DecodeString(strings.TrimPrefix(root, "0x"))
-				if err == nil {
-					if common.HexToHash(root) == common.BytesToHash(bytes) {
-						moduleRootMatched = true
-						break
-					}
-					continue
-				}
-				locator, locatorErr := server_common.NewMachineLocator(root)
-				if locatorErr != nil {
-					log.Warn("allowed-wasm-module-roots: value not a hex nor valid path:", "value", root, "locatorErr", locatorErr, "decodeErr", err)
-					continue
-				}
-				path := locator.GetMachinePath(moduleRoot)
-				if _, err := os.Stat(path); err == nil {
-					moduleRootMatched = true
-					break
-				}
-			}
-			if !moduleRootMatched {
-				log.Error("on-chain WASM module root did not match with any of the allowed WASM module roots")
-				return 1
-			}
-		} else {
-			// If no allowed module roots were provided in config, check if we have a validator machine directory for the on-chain WASM module root
-			locator, err := server_common.NewMachineLocator(nodeConfig.Validation.Wasm.RootPath)
-			if err != nil {
-				log.Warn("failed to create machine locator. Skipping the check for compatibility with on-chain WASM module root", "err", err)
-			} else {
-				path := locator.GetMachinePath(moduleRoot)
-				if _, err := os.Stat(path); err != nil {
-					log.Error("unable to find validator machine directory for the on-chain WASM module root", "err", err)
-					return 1
-				}
-			}
+			log.Warn("failed to check if node is compatible with on-chain WASM module root", "err", err)
 		}
 	}
 
@@ -524,6 +472,10 @@ func mainImpl() int {
 	if nodeConfig.BlocksReExecutor.Enable && l2BlockChain != nil {
 		blocksReExecutor = blocksreexecutor.New(&nodeConfig.BlocksReExecutor, l2BlockChain, fatalErrChan)
 		if nodeConfig.Init.ThenQuit {
+			if err := gethexec.PopulateStylusTargetCache(&nodeConfig.Execution.StylusTarget); err != nil {
+				log.Error("error populating stylus target cache", "err", err)
+				return 1
+			}
 			success := make(chan struct{})
 			blocksReExecutor.Start(ctx, success)
 			deferFuncs = append(deferFuncs, func() { blocksReExecutor.StopAndWait() })
@@ -1058,14 +1010,15 @@ func initReorg(initConfig conf.InitConfig, chainConfig *params.ChainConfig, inbo
 			return nil
 		}
 		// Reorg out the batch containing the next message
-		var missing bool
+		var found bool
 		var err error
-		batchCount, missing, err = inboxTracker.FindInboxBatchContainingMessage(messageIndex + 1)
+		batchCount, found, err = inboxTracker.FindInboxBatchContainingMessage(messageIndex + 1)
 		if err != nil {
 			return err
 		}
-		if missing {
-			return fmt.Errorf("cannot reorg to unknown message index %v", messageIndex)
+		if !found {
+			log.Warn("init-reorg: no need to reorg, because message ahead of chain", "messageIndex", messageIndex)
+			return nil
 		}
 	}
 	return inboxTracker.ReorgBatchesTo(batchCount)
@@ -1078,3 +1031,57 @@ type NodeConfigFetcher struct {
 func (f *NodeConfigFetcher) Get() *arbnode.Config {
 	return &f.LiveConfig.Get().Node
 }
+
+func checkWasmModuleRootCompatibility(ctx context.Context, wasmConfig valnode.WasmConfig, l1Client *ethclient.Client, rollupAddrs chaininfo.RollupAddresses) error {
+	// Fetch current on-chain WASM module root
+	rollupUserLogic, err := rollupgen.NewRollupUserLogic(rollupAddrs.Rollup, l1Client)
+	if err != nil {
+		return fmt.Errorf("failed to create RollupUserLogic: %w", err)
+	}
+	moduleRoot, err := rollupUserLogic.WasmModuleRoot(&bind.CallOpts{Context: ctx})
+	if err != nil {
+		return fmt.Errorf("failed to get on-chain WASM module root: %w", err)
+	}
+	if (moduleRoot == common.Hash{}) {
+		return errors.New("on-chain WASM module root is zero")
+	}
+	// Check if the on-chain WASM module root belongs to the set of allowed module roots
+	allowedWasmModuleRoots := wasmConfig.AllowedWasmModuleRoots
+	if len(allowedWasmModuleRoots) > 0 {
+		moduleRootMatched := false
+		for _, root := range allowedWasmModuleRoots {
+			bytes, err := hex.DecodeString(strings.TrimPrefix(root, "0x"))
+			if err == nil {
+				if common.HexToHash(root) == common.BytesToHash(bytes) {
+					moduleRootMatched = true
+					break
+				}
+				continue
+			}
+			locator, locatorErr := server_common.NewMachineLocator(root)
+			if locatorErr != nil {
+				log.Warn("allowed-wasm-module-roots: value not a hex nor valid path:", "value", root, "locatorErr", locatorErr, "decodeErr", err)
+				continue
+			}
+			path := locator.GetMachinePath(moduleRoot)
+			if _, err := os.Stat(path); err == nil {
+				moduleRootMatched = true
+				break
+			}
+		}
+		if !moduleRootMatched {
+			return errors.New("on-chain WASM module root did not match with any of the allowed WASM module roots")
+		}
+	} else {
+		// If no allowed module roots were provided in config, check if we have a validator machine directory for the on-chain WASM module root
+		locator, err := server_common.NewMachineLocator(wasmConfig.RootPath)
+		if err != nil {
+			return fmt.Errorf("failed to create machine locator: %w", err)
+		}
+		path := locator.GetMachinePath(moduleRoot)
+		if _, err := os.Stat(path); err != nil {
+			return fmt.Errorf("unable to find validator machine directory for the on-chain WASM module root: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/contracts b/contracts
index 23fc796282..7396313311 160000
--- a/contracts
+++ b/contracts
@@ -1 +1 @@
-Subproject commit 23fc79628292aa5d604d449fed48937ae7faeb2f
+Subproject commit 7396313311ab17cb30e2eef27cccf96f0a9e8f7f
diff --git a/das/dasRpcClient.go b/das/dasRpcClient.go
index 7d48ed796d..241f2196b1 100644
--- a/das/dasRpcClient.go
+++ b/das/dasRpcClient.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"golang.org/x/sync/errgroup"
 
 	"github.com/ethereum/go-ethereum/rpc"
@@ -21,6 +22,17 @@ import (
 	"github.com/offchainlabs/nitro/util/signature"
 )
 
+var (
+	rpcClientStoreRequestGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/requests", nil)
+	rpcClientStoreSuccessGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/success", nil)
+	rpcClientStoreFailureGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/failure", nil)
+	rpcClientStoreStoredBytesGauge  = metrics.NewRegisteredGauge("arb/das/rpcclient/store/bytes", nil)
+	rpcClientStoreDurationHistogram = metrics.NewRegisteredHistogram("arb/das/rpcclient/store/duration", nil, metrics.NewBoundedHistogramSample())
+
+	rpcClientSendChunkSuccessGauge = metrics.NewRegisteredGauge("arb/das/rpcclient/sendchunk/success", nil)
+	rpcClientSendChunkFailureGauge = metrics.NewRegisteredGauge("arb/das/rpcclient/sendchunk/failure", nil)
+)
+
 type DASRPCClient struct { // implements DataAvailabilityService
 	clnt      *rpc.Client
 	url       string
@@ -58,8 +70,20 @@ func NewDASRPCClient(target string, signer signature.DataSignerFunc, maxStoreChu
 }
 
 func (c *DASRPCClient) Store(ctx context.Context, message []byte, timeout uint64) (*daprovider.DataAvailabilityCertificate, error) {
+	rpcClientStoreRequestGauge.Inc(1)
+	start := time.Now()
+	success := false
+	defer func() {
+		if success {
+			rpcClientStoreSuccessGauge.Inc(1)
+		} else {
+			rpcClientStoreFailureGauge.Inc(1)
+		}
+		rpcClientStoreDurationHistogram.Update(time.Since(start).Nanoseconds())
+	}()
+
 	// #nosec G115
-	timestamp := uint64(time.Now().Unix())
+	timestamp := uint64(start.Unix())
 	nChunks := uint64(len(message)) / c.chunkSize
 	lastChunkSize := uint64(len(message)) % c.chunkSize
 	if lastChunkSize > 0 {
@@ -116,6 +140,9 @@ func (c *DASRPCClient) Store(ctx context.Context, message []byte, timeout uint64
 		return nil, err
 	}
 
+	rpcClientStoreStoredBytesGauge.Inc(int64(len(message)))
+	success = true
+
 	return &daprovider.DataAvailabilityCertificate{
 		DataHash:    common.BytesToHash(storeResult.DataHash),
 		Timeout:     uint64(storeResult.Timeout),
@@ -133,8 +160,10 @@ func (c *DASRPCClient) sendChunk(ctx context.Context, batchId, i uint64, chunk [
 	}
 
 	if err := c.clnt.CallContext(ctx, nil, "das_sendChunk", hexutil.Uint64(batchId), hexutil.Uint64(i), hexutil.Bytes(chunk), hexutil.Bytes(chunkReqSig)); err != nil {
+		rpcClientSendChunkFailureGauge.Inc(1)
 		return err
 	}
+	rpcClientSendChunkSuccessGauge.Inc(1)
 	return nil
 }
 
diff --git a/deploy/deploy.go b/deploy/deploy.go
index 5e7755cae3..bb4b2e6594 100644
--- a/deploy/deploy.go
+++ b/deploy/deploy.go
@@ -20,59 +20,67 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 )
 
-func andTxSucceeded(ctx context.Context, l1Reader *headerreader.HeaderReader, tx *types.Transaction, err error) error {
+func andTxSucceeded(ctx context.Context, parentChainReader *headerreader.HeaderReader, tx *types.Transaction, err error) error {
 	if err != nil {
 		return fmt.Errorf("error submitting tx: %w", err)
 	}
-	_, err = l1Reader.WaitForTxApproval(ctx, tx)
+	_, err = parentChainReader.WaitForTxApproval(ctx, tx)
 	if err != nil {
 		return fmt.Errorf("error executing tx: %w", err)
 	}
 	return nil
 }
 
-func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, isUsingFeeToken bool) (common.Address, error) {
-	client := l1Reader.Client()
+func deployBridgeCreator(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, chainSupportsBlobs bool) (common.Address, error) {
+	client := parentChainReader.Client()
 
 	/// deploy eth based templates
 	bridgeTemplate, tx, _, err := bridgegen.DeployBridge(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge deploy error: %w", err)
 	}
 
-	reader4844, tx, _, err := yulgen.DeployReader4844(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	var reader4844 common.Address
+	if chainSupportsBlobs {
+		reader4844, tx, _, err = yulgen.DeployReader4844(auth, client)
+		err = andTxSucceeded(ctx, parentChainReader, tx, err)
+		if err != nil {
+			return common.Address{}, fmt.Errorf("blob basefee reader deploy error: %w", err)
+		}
+	}
+	seqInboxTemplateEthBased, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, false)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
-		return common.Address{}, fmt.Errorf("blob basefee reader deploy error: %w", err)
+		return common.Address{}, fmt.Errorf("sequencer inbox eth based deploy error: %w", err)
 	}
-	seqInboxTemplate, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, isUsingFeeToken)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	seqInboxTemplateERC20Based, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, true)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
-		return common.Address{}, fmt.Errorf("sequencer inbox deploy error: %w", err)
+		return common.Address{}, fmt.Errorf("sequencer inbox erc20 based deploy error: %w", err)
 	}
 
 	inboxTemplate, tx, _, err := bridgegen.DeployInbox(auth, client, maxDataSize)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("inbox deploy error: %w", err)
 	}
 
 	rollupEventBridgeTemplate, tx, _, err := rollupgen.DeployRollupEventInbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("rollup event bridge deploy error: %w", err)
 	}
 
 	outboxTemplate, tx, _, err := bridgegen.DeployOutbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("outbox deploy error: %w", err)
 	}
 
 	ethBasedTemplates := rollupgen.BridgeCreatorBridgeContracts{
 		Bridge:           bridgeTemplate,
-		SequencerInbox:   seqInboxTemplate,
+		SequencerInbox:   seqInboxTemplateEthBased,
 		Inbox:            inboxTemplate,
 		RollupEventInbox: rollupEventBridgeTemplate,
 		Outbox:           outboxTemplate,
@@ -80,39 +88,39 @@ func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 
 	/// deploy ERC20 based templates
 	erc20BridgeTemplate, tx, _, err := bridgegen.DeployERC20Bridge(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge deploy error: %w", err)
 	}
 
 	erc20InboxTemplate, tx, _, err := bridgegen.DeployERC20Inbox(auth, client, maxDataSize)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("inbox deploy error: %w", err)
 	}
 
 	erc20RollupEventBridgeTemplate, tx, _, err := rollupgen.DeployERC20RollupEventInbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("rollup event bridge deploy error: %w", err)
 	}
 
 	erc20OutboxTemplate, tx, _, err := bridgegen.DeployERC20Outbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("outbox deploy error: %w", err)
 	}
 
 	erc20BasedTemplates := rollupgen.BridgeCreatorBridgeContracts{
 		Bridge:           erc20BridgeTemplate,
-		SequencerInbox:   seqInboxTemplate,
+		SequencerInbox:   seqInboxTemplateERC20Based,
 		Inbox:            erc20InboxTemplate,
 		RollupEventInbox: erc20RollupEventBridgeTemplate,
 		Outbox:           erc20OutboxTemplate,
 	}
 
 	bridgeCreatorAddr, tx, _, err := rollupgen.DeployBridgeCreator(auth, client, ethBasedTemplates, erc20BasedTemplates)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge creator deploy error: %w", err)
 	}
@@ -120,40 +128,40 @@ func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 	return bridgeCreatorAddr, nil
 }
 
-func deployChallengeFactory(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts) (common.Address, common.Address, error) {
-	client := l1Reader.Client()
+func deployChallengeFactory(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts) (common.Address, common.Address, error) {
+	client := parentChainReader.Client()
 	osp0, tx, _, err := ospgen.DeployOneStepProver0(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("osp0 deploy error: %w", err)
 	}
 
 	ospMem, tx, _, err := ospgen.DeployOneStepProverMemory(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospMemory deploy error: %w", err)
 	}
 
 	ospMath, tx, _, err := ospgen.DeployOneStepProverMath(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospMath deploy error: %w", err)
 	}
 
 	ospHostIo, tx, _, err := ospgen.DeployOneStepProverHostIo(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospHostIo deploy error: %w", err)
 	}
 
 	challengeManagerAddr, tx, _, err := challengegen.DeployChallengeManager(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("challenge manager deploy error: %w", err)
 	}
 
 	ospEntryAddr, tx, _, err := ospgen.DeployOneStepProofEntry(auth, client, osp0, ospMem, ospMath, ospHostIo)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospEntry deploy error: %w", err)
 	}
@@ -161,55 +169,55 @@ func deployChallengeFactory(ctx context.Context, l1Reader *headerreader.HeaderRe
 	return ospEntryAddr, challengeManagerAddr, nil
 }
 
-func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, isUsingFeeToken bool) (*rollupgen.RollupCreator, common.Address, common.Address, common.Address, error) {
-	bridgeCreator, err := deployBridgeCreator(ctx, l1Reader, auth, maxDataSize, isUsingFeeToken)
+func deployRollupCreator(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, chainSupportsBlobs bool) (*rollupgen.RollupCreator, common.Address, common.Address, common.Address, error) {
+	bridgeCreator, err := deployBridgeCreator(ctx, parentChainReader, auth, maxDataSize, chainSupportsBlobs)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("bridge creator deploy error: %w", err)
 	}
 
-	ospEntryAddr, challengeManagerAddr, err := deployChallengeFactory(ctx, l1Reader, auth)
+	ospEntryAddr, challengeManagerAddr, err := deployChallengeFactory(ctx, parentChainReader, auth)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, err
 	}
 
-	rollupAdminLogic, tx, _, err := rollupgen.DeployRollupAdminLogic(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupAdminLogic, tx, _, err := rollupgen.DeployRollupAdminLogic(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup admin logic deploy error: %w", err)
 	}
 
-	rollupUserLogic, tx, _, err := rollupgen.DeployRollupUserLogic(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupUserLogic, tx, _, err := rollupgen.DeployRollupUserLogic(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup user logic deploy error: %w", err)
 	}
 
-	rollupCreatorAddress, tx, rollupCreator, err := rollupgen.DeployRollupCreator(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupCreatorAddress, tx, rollupCreator, err := rollupgen.DeployRollupCreator(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup creator deploy error: %w", err)
 	}
 
-	upgradeExecutor, tx, _, err := upgrade_executorgen.DeployUpgradeExecutor(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	upgradeExecutor, tx, _, err := upgrade_executorgen.DeployUpgradeExecutor(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("upgrade executor deploy error: %w", err)
 	}
 
-	validatorUtils, tx, _, err := rollupgen.DeployValidatorUtils(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	validatorUtils, tx, _, err := rollupgen.DeployValidatorUtils(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("validator utils deploy error: %w", err)
 	}
 
-	validatorWalletCreator, tx, _, err := rollupgen.DeployValidatorWalletCreator(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	validatorWalletCreator, tx, _, err := rollupgen.DeployValidatorWalletCreator(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("validator wallet creator deploy error: %w", err)
 	}
 
-	l2FactoriesDeployHelper, tx, _, err := rollupgen.DeployDeployHelper(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	l2FactoriesDeployHelper, tx, _, err := rollupgen.DeployDeployHelper(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("deploy helper creator deploy error: %w", err)
 	}
@@ -226,7 +234,7 @@ func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 		validatorWalletCreator,
 		l2FactoriesDeployHelper,
 	)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup set template error: %w", err)
 	}
@@ -234,12 +242,12 @@ func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 	return rollupCreator, rollupCreatorAddress, validatorUtils, validatorWalletCreator, nil
 }
 
-func DeployOnL1(ctx context.Context, parentChainReader *headerreader.HeaderReader, deployAuth *bind.TransactOpts, batchPosters []common.Address, batchPosterManager common.Address, authorizeValidators uint64, config rollupgen.Config, nativeToken common.Address, maxDataSize *big.Int, isUsingFeeToken bool) (*chaininfo.RollupAddresses, error) {
+func DeployOnParentChain(ctx context.Context, parentChainReader *headerreader.HeaderReader, deployAuth *bind.TransactOpts, batchPosters []common.Address, batchPosterManager common.Address, authorizeValidators uint64, config rollupgen.Config, nativeToken common.Address, maxDataSize *big.Int, chainSupportsBlobs bool) (*chaininfo.RollupAddresses, error) {
 	if config.WasmModuleRoot == (common.Hash{}) {
 		return nil, errors.New("no machine specified")
 	}
 
-	rollupCreator, _, validatorUtils, validatorWalletCreator, err := deployRollupCreator(ctx, parentChainReader, deployAuth, maxDataSize, isUsingFeeToken)
+	rollupCreator, _, validatorUtils, validatorWalletCreator, err := deployRollupCreator(ctx, parentChainReader, deployAuth, maxDataSize, chainSupportsBlobs)
 	if err != nil {
 		return nil, fmt.Errorf("error deploying rollup creator: %w", err)
 	}
diff --git a/execution/gethexec/block_recorder.go b/execution/gethexec/block_recorder.go
index 8879c90702..a31b6b3736 100644
--- a/execution/gethexec/block_recorder.go
+++ b/execution/gethexec/block_recorder.go
@@ -16,6 +16,7 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/execution"
+	flag "github.com/spf13/pflag"
 )
 
 // BlockRecorder uses a separate statedatabase from the blockchain.
@@ -25,6 +26,8 @@ import (
 // Most recent/advanced header we ever computed (lastHdr)
 // Hopefully - some recent valid block. For that we always keep one candidate block until it becomes validated.
 type BlockRecorder struct {
+	config *BlockRecorderConfig
+
 	recordingDatabase *arbitrum.RecordingDatabase
 	execEngine        *ExecutionEngine
 
@@ -39,10 +42,33 @@ type BlockRecorder struct {
 	preparedLock  sync.Mutex
 }
 
-func NewBlockRecorder(config *arbitrum.RecordingDatabaseConfig, execEngine *ExecutionEngine, ethDb ethdb.Database) *BlockRecorder {
+type BlockRecorderConfig struct {
+	TrieDirtyCache int `koanf:"trie-dirty-cache"`
+	TrieCleanCache int `koanf:"trie-clean-cache"`
+	MaxPrepared    int `koanf:"max-prepared"`
+}
+
+var DefaultBlockRecorderConfig = BlockRecorderConfig{
+	TrieDirtyCache: 1024,
+	TrieCleanCache: 16,
+	MaxPrepared:    1000,
+}
+
+func BlockRecorderConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Int(prefix+".trie-dirty-cache", DefaultBlockRecorderConfig.TrieDirtyCache, "like trie-dirty-cache for the separate, recording database (used for validation)")
+	f.Int(prefix+".trie-clean-cache", DefaultBlockRecorderConfig.TrieCleanCache, "like trie-clean-cache for the separate, recording database (used for validation)")
+	f.Int(prefix+".max-prepared", DefaultBlockRecorderConfig.MaxPrepared, "max references to store in the recording database")
+}
+
+func NewBlockRecorder(config *BlockRecorderConfig, execEngine *ExecutionEngine, ethDb ethdb.Database) *BlockRecorder {
+	dbConfig := arbitrum.RecordingDatabaseConfig{
+		TrieDirtyCache: config.TrieDirtyCache,
+		TrieCleanCache: config.TrieCleanCache,
+	}
 	recorder := &BlockRecorder{
+		config:            config,
 		execEngine:        execEngine,
-		recordingDatabase: arbitrum.NewRecordingDatabase(config, ethDb, execEngine.bc),
+		recordingDatabase: arbitrum.NewRecordingDatabase(&dbConfig, ethDb, execEngine.bc),
 	}
 	execEngine.SetRecorder(recorder)
 	return recorder
@@ -303,7 +329,7 @@ func (r *BlockRecorder) PrepareForRecord(ctx context.Context, start, end arbutil
 		r.updateLastHdr(header)
 		hdrNum++
 	}
-	r.preparedAddTrim(references, 1000)
+	r.preparedAddTrim(references, r.config.MaxPrepared)
 	return nil
 }
 
diff --git a/execution/gethexec/blockchain.go b/execution/gethexec/blockchain.go
index 98ce4811d1..9b0c1a6f2f 100644
--- a/execution/gethexec/blockchain.go
+++ b/execution/gethexec/blockchain.go
@@ -37,7 +37,7 @@ type CachingConfig struct {
 	SnapshotRestoreGasLimit            uint64        `koanf:"snapshot-restore-gas-limit"`
 	MaxNumberOfBlocksToSkipStateSaving uint32        `koanf:"max-number-of-blocks-to-skip-state-saving"`
 	MaxAmountOfGasToSkipStateSaving    uint64        `koanf:"max-amount-of-gas-to-skip-state-saving"`
-	StylusLRUCache                     uint32        `koanf:"stylus-lru-cache"`
+	StylusLRUCacheCapacity             uint32        `koanf:"stylus-lru-cache-capacity"`
 	StateScheme                        string        `koanf:"state-scheme"`
 	StateHistory                       uint64        `koanf:"state-history"`
 }
@@ -54,7 +54,7 @@ func CachingConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Uint64(prefix+".snapshot-restore-gas-limit", DefaultCachingConfig.SnapshotRestoreGasLimit, "maximum gas rolled back to recover snapshot")
 	f.Uint32(prefix+".max-number-of-blocks-to-skip-state-saving", DefaultCachingConfig.MaxNumberOfBlocksToSkipStateSaving, "maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues")
 	f.Uint64(prefix+".max-amount-of-gas-to-skip-state-saving", DefaultCachingConfig.MaxAmountOfGasToSkipStateSaving, "maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues")
-	f.Uint32(prefix+".stylus-lru-cache", DefaultCachingConfig.StylusLRUCache, "initialized stylus programs to keep in LRU cache")
+	f.Uint32(prefix+".stylus-lru-cache-capacity", DefaultCachingConfig.StylusLRUCacheCapacity, "capacity, in megabytes, of the LRU cache that keeps initialized stylus programs")
 	f.String(prefix+".state-scheme", DefaultCachingConfig.StateScheme, "scheme to use for state trie storage (hash, path)")
 	f.Uint64(prefix+".state-history", DefaultCachingConfig.StateHistory, "number of recent blocks to retain state history for (path state-scheme only)")
 }
@@ -76,7 +76,7 @@ var DefaultCachingConfig = CachingConfig{
 	SnapshotRestoreGasLimit:            300_000_000_000,
 	MaxNumberOfBlocksToSkipStateSaving: 0,
 	MaxAmountOfGasToSkipStateSaving:    0,
-	StylusLRUCache:                     256,
+	StylusLRUCacheCapacity:             256,
 	StateScheme:                        rawdb.HashScheme,
 	StateHistory:                       getStateHistory(DefaultSequencerConfig.MaxBlockSpeed),
 }
diff --git a/execution/gethexec/executionengine.go b/execution/gethexec/executionengine.go
index 8594d5867d..a0f3a2f59a 100644
--- a/execution/gethexec/executionengine.go
+++ b/execution/gethexec/executionengine.go
@@ -7,7 +7,7 @@
 package gethexec
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 */
@@ -150,7 +150,7 @@ func (s *ExecutionEngine) MarkFeedStart(to arbutil.MessageIndex) {
 	}
 }
 
-func populateStylusTargetCache(targetConfig *StylusTargetConfig) error {
+func PopulateStylusTargetCache(targetConfig *StylusTargetConfig) error {
 	localTarget := rawdb.LocalTarget()
 	targets := targetConfig.WasmTargets()
 	var nativeSet bool
@@ -182,11 +182,11 @@ func populateStylusTargetCache(targetConfig *StylusTargetConfig) error {
 	return nil
 }
 
-func (s *ExecutionEngine) Initialize(rustCacheSize uint32, targetConfig *StylusTargetConfig) error {
-	if rustCacheSize != 0 {
-		programs.ResizeWasmLruCache(rustCacheSize)
+func (s *ExecutionEngine) Initialize(rustCacheCapacityMB uint32, targetConfig *StylusTargetConfig) error {
+	if rustCacheCapacityMB != 0 {
+		programs.SetWasmLruCacheCapacity(arbmath.SaturatingUMul(uint64(rustCacheCapacityMB), 1024*1024))
 	}
-	if err := populateStylusTargetCache(targetConfig); err != nil {
+	if err := PopulateStylusTargetCache(targetConfig); err != nil {
 		return fmt.Errorf("error populating stylus target cache: %w", err)
 	}
 	return nil
@@ -963,4 +963,15 @@ func (s *ExecutionEngine) Start(ctx_in context.Context) {
 			}
 		}
 	})
+	// periodically update stylus lru cache metrics
+	s.LaunchThread(func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-time.After(time.Minute):
+				programs.GetWasmLruCacheMetrics()
+			}
+		}
+	})
 }
diff --git a/execution/gethexec/node.go b/execution/gethexec/node.go
index f1ca64082d..cb06a58e74 100644
--- a/execution/gethexec/node.go
+++ b/execution/gethexec/node.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"sort"
 	"sync/atomic"
 	"testing"
 
@@ -60,6 +61,11 @@ func (c *StylusTargetConfig) Validate() error {
 	for target := range targetsSet {
 		targets = append(targets, target)
 	}
+	sort.Slice(
+		targets,
+		func(i, j int) bool {
+			return targets[i] < targets[j]
+		})
 	c.wasmTargets = targets
 	return nil
 }
@@ -79,19 +85,19 @@ func StylusTargetConfigAddOptions(prefix string, f *flag.FlagSet) {
 }
 
 type Config struct {
-	ParentChainReader         headerreader.Config              `koanf:"parent-chain-reader" reload:"hot"`
-	Sequencer                 SequencerConfig                  `koanf:"sequencer" reload:"hot"`
-	RecordingDatabase         arbitrum.RecordingDatabaseConfig `koanf:"recording-database"`
-	TxPreChecker              TxPreCheckerConfig               `koanf:"tx-pre-checker" reload:"hot"`
-	Forwarder                 ForwarderConfig                  `koanf:"forwarder"`
-	ForwardingTarget          string                           `koanf:"forwarding-target"`
-	SecondaryForwardingTarget []string                         `koanf:"secondary-forwarding-target"`
-	Caching                   CachingConfig                    `koanf:"caching"`
-	RPC                       arbitrum.Config                  `koanf:"rpc"`
-	TxLookupLimit             uint64                           `koanf:"tx-lookup-limit"`
-	EnablePrefetchBlock       bool                             `koanf:"enable-prefetch-block"`
-	SyncMonitor               SyncMonitorConfig                `koanf:"sync-monitor"`
-	StylusTarget              StylusTargetConfig               `koanf:"stylus-target"`
+	ParentChainReader         headerreader.Config `koanf:"parent-chain-reader" reload:"hot"`
+	Sequencer                 SequencerConfig     `koanf:"sequencer" reload:"hot"`
+	RecordingDatabase         BlockRecorderConfig `koanf:"recording-database"`
+	TxPreChecker              TxPreCheckerConfig  `koanf:"tx-pre-checker" reload:"hot"`
+	Forwarder                 ForwarderConfig     `koanf:"forwarder"`
+	ForwardingTarget          string              `koanf:"forwarding-target"`
+	SecondaryForwardingTarget []string            `koanf:"secondary-forwarding-target"`
+	Caching                   CachingConfig       `koanf:"caching"`
+	RPC                       arbitrum.Config     `koanf:"rpc"`
+	TxLookupLimit             uint64              `koanf:"tx-lookup-limit"`
+	EnablePrefetchBlock       bool                `koanf:"enable-prefetch-block"`
+	SyncMonitor               SyncMonitorConfig   `koanf:"sync-monitor"`
+	StylusTarget              StylusTargetConfig  `koanf:"stylus-target"`
 
 	forwardingTarget string
 }
@@ -124,7 +130,7 @@ func ConfigAddOptions(prefix string, f *flag.FlagSet) {
 	arbitrum.ConfigAddOptions(prefix+".rpc", f)
 	SequencerConfigAddOptions(prefix+".sequencer", f)
 	headerreader.AddOptions(prefix+".parent-chain-reader", f)
-	arbitrum.RecordingDatabaseConfigAddOptions(prefix+".recording-database", f)
+	BlockRecorderConfigAddOptions(prefix+".recording-database", f)
 	f.String(prefix+".forwarding-target", ConfigDefault.ForwardingTarget, "transaction forwarding target URL, or \"null\" to disable forwarding (iff not sequencer)")
 	f.StringSlice(prefix+".secondary-forwarding-target", ConfigDefault.SecondaryForwardingTarget, "secondary transaction forwarding target URL")
 	AddOptionsForNodeForwarderConfig(prefix+".forwarder", f)
@@ -140,7 +146,7 @@ var ConfigDefault = Config{
 	RPC:                       arbitrum.DefaultConfig,
 	Sequencer:                 DefaultSequencerConfig,
 	ParentChainReader:         headerreader.DefaultConfig,
-	RecordingDatabase:         arbitrum.DefaultRecordingDatabaseConfig,
+	RecordingDatabase:         DefaultBlockRecorderConfig,
 	ForwardingTarget:          "",
 	SecondaryForwardingTarget: []string{},
 	TxPreChecker:              DefaultTxPreCheckerConfig,
@@ -309,7 +315,7 @@ func (n *ExecutionNode) MarkFeedStart(to arbutil.MessageIndex) {
 
 func (n *ExecutionNode) Initialize(ctx context.Context) error {
 	config := n.ConfigFetcher()
-	err := n.ExecEngine.Initialize(config.Caching.StylusLRUCache, &config.StylusTarget)
+	err := n.ExecEngine.Initialize(config.Caching.StylusLRUCacheCapacity, &config.StylusTarget)
 	if err != nil {
 		return fmt.Errorf("error initializing execution engine: %w", err)
 	}
diff --git a/execution/gethexec/wasmstorerebuilder.go b/execution/gethexec/wasmstorerebuilder.go
index 698ba3ec8a..e3eb8e9268 100644
--- a/execution/gethexec/wasmstorerebuilder.go
+++ b/execution/gethexec/wasmstorerebuilder.go
@@ -63,7 +63,7 @@ func RebuildWasmStore(ctx context.Context, wasmStore ethdb.KeyValueStore, chainD
 	var err error
 	var stateDb *state.StateDB
 
-	if err := populateStylusTargetCache(targetConfig); err != nil {
+	if err := PopulateStylusTargetCache(targetConfig); err != nil {
 		return fmt.Errorf("error populating stylus target cache: %w", err)
 	}
 
diff --git a/go-ethereum b/go-ethereum
index 81114dde8a..17cd001675 160000
--- a/go-ethereum
+++ b/go-ethereum
@@ -1 +1 @@
-Subproject commit 81114dde8a26bae90c188605c4a36d5919a4a265
+Subproject commit 17cd00167543a5a2b0b083e32820051100154c2f
diff --git a/nitro-testnode b/nitro-testnode
index f328006579..72141dd495 160000
--- a/nitro-testnode
+++ b/nitro-testnode
@@ -1 +1 @@
-Subproject commit f328006579cbefe22c6c57de3d6b86397fde4438
+Subproject commit 72141dd495ad965aa2a23723ea3e755037903ad7
diff --git a/precompiles/ArbWasm.go b/precompiles/ArbWasm.go
index 9f42cacb5a..bc24c8a6e8 100644
--- a/precompiles/ArbWasm.go
+++ b/precompiles/ArbWasm.go
@@ -5,6 +5,8 @@ package precompiles
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	gethparams "github.com/ethereum/go-ethereum/params"
 	"github.com/offchainlabs/nitro/arbos/programs"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -32,12 +34,13 @@ func (con ArbWasm) ActivateProgram(c ctx, evm mech, value huge, program addr) (u
 	debug := evm.ChainConfig().DebugMode()
 	runMode := c.txProcessor.RunMode()
 	programs := c.State.Programs()
+	arbosVersion := c.State.ArbOSVersion()
 
 	// charge a fixed cost up front to begin activation
 	if err := c.Burn(1659168); err != nil {
 		return 0, nil, err
 	}
-	version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, runMode, debug)
+	version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, arbosVersion, runMode, debug)
 	if takeAllGas {
 		_ = c.BurnOut()
 	}
@@ -133,6 +136,9 @@ func (con ArbWasm) MinInitGas(c ctx, _ mech) (uint64, uint64, error) {
 	params, err := c.State.Programs().Params()
 	init := uint64(params.MinInitGas) * programs.MinInitGasUnits
 	cached := uint64(params.MinCachedInitGas) * programs.MinCachedGasUnits
+	if c.State.ArbOSVersion() < gethparams.ArbosVersion_StylusChargingFixes {
+		return 0, 0, vm.ErrExecutionReverted
+	}
 	return init, cached, err
 }
 
diff --git a/pubsub/consumer.go b/pubsub/consumer.go
index df3695606d..bd73e729e7 100644
--- a/pubsub/consumer.go
+++ b/pubsub/consumer.go
@@ -77,6 +77,10 @@ func (c *Consumer[Request, Response]) Start(ctx context.Context) {
 	)
 }
 
+func (c *Consumer[Request, Response]) Id() string {
+	return c.id
+}
+
 func (c *Consumer[Request, Response]) StopAndWait() {
 	c.StopWaiter.StopAndWait()
 	c.deleteHeartBeat(c.GetParentContext())
@@ -164,10 +168,12 @@ func (c *Consumer[Request, Response]) SetResult(ctx context.Context, messageID s
 	if err != nil {
 		return fmt.Errorf("marshaling result: %w", err)
 	}
+	log.Debug("consumer: setting result", "cid", c.id, "messageId", messageID)
 	acquired, err := c.client.SetNX(ctx, messageID, resp, c.cfg.ResponseEntryTimeout).Result()
 	if err != nil || !acquired {
 		return fmt.Errorf("setting result for  message: %v, error: %w", messageID, err)
 	}
+	log.Debug("consumer: xack", "cid", c.id, "messageId", messageID)
 	if _, err := c.client.XAck(ctx, c.redisStream, c.redisGroup, messageID).Result(); err != nil {
 		return fmt.Errorf("acking message: %v, error: %w", messageID, err)
 	}
diff --git a/pubsub/producer.go b/pubsub/producer.go
index 2b1cdb5e3f..5eec3a4b52 100644
--- a/pubsub/producer.go
+++ b/pubsub/producer.go
@@ -205,35 +205,39 @@ func setMinIdInt(min *[2]uint64, id string) error {
 // checkResponses checks iteratively whether response for the promise is ready.
 func (p *Producer[Request, Response]) checkResponses(ctx context.Context) time.Duration {
 	minIdInt := [2]uint64{math.MaxUint64, math.MaxUint64}
+	log.Debug("redis producer: check responses starting")
 	p.promisesLock.Lock()
 	defer p.promisesLock.Unlock()
 	responded := 0
 	errored := 0
+	checked := 0
 	for id, promise := range p.promises {
 		if ctx.Err() != nil {
 			return 0
 		}
+		checked++
 		res, err := p.client.Get(ctx, id).Result()
 		if err != nil {
 			errSetId := setMinIdInt(&minIdInt, id)
 			if errSetId != nil {
-				log.Error("error setting minId", "err", err)
+				log.Error("redis producer: error setting minId", "err", err)
 				return p.cfg.CheckResultInterval
 			}
 			if !errors.Is(err, redis.Nil) {
-				log.Error("Error reading value in redis", "key", id, "error", err)
+				log.Error("redis producer: Error reading value in redis", "key", id, "error", err)
 			}
 			continue
 		}
 		var resp Response
 		if err := json.Unmarshal([]byte(res), &resp); err != nil {
 			promise.ProduceError(fmt.Errorf("error unmarshalling: %w", err))
-			log.Error("Error unmarshaling", "value", res, "error", err)
+			log.Error("redis producer: Error unmarshaling", "value", res, "error", err)
 			errored++
 		} else {
 			promise.Produce(resp)
 			responded++
 		}
+		p.client.Del(ctx, id)
 		delete(p.promises, id)
 	}
 	var trimmed int64
@@ -245,7 +249,7 @@ func (p *Producer[Request, Response]) checkResponses(ctx context.Context) time.D
 	} else {
 		trimmed, trimErr = p.client.XTrimMaxLen(ctx, p.redisStream, 0).Result()
 	}
-	log.Trace("trimming", "id", minId, "trimmed", trimmed, "responded", responded, "errored", errored, "trim-err", trimErr)
+	log.Debug("trimming", "id", minId, "trimmed", trimmed, "responded", responded, "errored", errored, "trim-err", trimErr, "checked", checked)
 	return p.cfg.CheckResultInterval
 }
 
diff --git a/scripts/build-brotli.sh b/scripts/build-brotli.sh
index 7160936baa..1a23a88ae0 100755
--- a/scripts/build-brotli.sh
+++ b/scripts/build-brotli.sh
@@ -2,7 +2,7 @@
 
 set -e
 
-mydir=`dirname $0`
+mydir=$(dirname "$0")
 cd "$mydir"
 
 BUILD_WASM=false
@@ -35,7 +35,7 @@ usage(){
     echo "all relative paths are relative to script location"
 }
 
-while getopts "s:t:c:D:wldhf" option; do
+while getopts "n:s:t:c:D:wldhf" option; do
     case $option in
         h)
             usage
@@ -62,6 +62,9 @@ while getopts "s:t:c:D:wldhf" option; do
         s)
             SOURCE_DIR="$OPTARG"
             ;;
+        *)
+            usage
+            ;;
     esac
 done
 
@@ -74,7 +77,7 @@ if [ ! -d "$TARGET_DIR" ]; then
     mkdir -p "${TARGET_DIR}lib"
     ln -s "lib" "${TARGET_DIR}lib64" # Fedora build
 fi
-TARGET_DIR_ABS=`cd -P "$TARGET_DIR"; pwd`
+TARGET_DIR_ABS=$(cd -P "$TARGET_DIR"; pwd)
 
 
 if $USE_DOCKER; then
@@ -94,9 +97,9 @@ cd "$SOURCE_DIR"
 if $BUILD_WASM; then
     mkdir -p buildfiles/build-wasm
     mkdir -p buildfiles/install-wasm
-    TEMP_INSTALL_DIR_ABS=`cd -P buildfiles/install-wasm; pwd`
+    TEMP_INSTALL_DIR_ABS=$(cd -P buildfiles/install-wasm; pwd)
     cd buildfiles/build-wasm
-    cmake ../../ -DCMAKE_C_COMPILER=emcc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-fPIC -DCMAKE_INSTALL_PREFIX="$TEMP_INSTALL_DIR_ABS" -DCMAKE_AR=`which emar` -DCMAKE_RANLIB=`which touch`
+    cmake ../../ -DCMAKE_C_COMPILER=emcc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-fPIC -DCMAKE_INSTALL_PREFIX="$TEMP_INSTALL_DIR_ABS" -DCMAKE_AR="$(which emar)" -DCMAKE_RANLIB="$(which touch)"
     make -j
     make install
     cp -rv "$TEMP_INSTALL_DIR_ABS/lib" "$TARGET_DIR_ABS/lib-wasm"
diff --git a/scripts/convert-databases.bash b/scripts/convert-databases.bash
index 3020b389b4..baddcdcacd 100755
--- a/scripts/convert-databases.bash
+++ b/scripts/convert-databases.bash
@@ -33,7 +33,7 @@ printStatus() {
 }
 
 printUsage() {
-echo Usage: $0 \[OPTIONS..\]
+echo Usage: "$0" \[OPTIONS..\]
     echo
     echo OPTIONS:
     echo "--dbconv          dbconv binary path (default: \"$DEFAULT_DBCONV\")"
@@ -42,15 +42,15 @@ echo Usage: $0 \[OPTIONS..\]
     echo "--force           remove destination directory if it exists"
     echo "--skip-existing   skip convertion of databases which directories already exist in the destination directory"
     echo "--clean           sets what should be removed in case of error, possible values:"
-	echo "                      \"failed\" - remove database which conversion failed (default)"
+    echo "                      \"failed\" - remove database which conversion failed (default)"
     echo "                      \"none\"   - remove nothing, leave unfinished and potentially corrupted databases"
     echo "                      \"all\"    - remove whole destination directory"
 }
 
 removeDir() {
     cmd="rm -r \"$1\""
-    echo $cmd
-    eval $cmd
+    echo "$cmd"
+    eval "$cmd"
     return $?
 }
 
@@ -62,7 +62,7 @@ cleanup() {
             ;;
         failed)
             echo "== Note: removing only failed destination directory"
-            dstdir=$(echo $dst/$1 | tr -s /)
+            dstdir=$(echo "$dst"/"$1" | tr -s /)
             removeDir "$dstdir"
             ;;
         none)
@@ -127,8 +127,8 @@ if $force && $skip_existing; then
     exit 1
 fi
 
-if [ $clean != "all" ] && [ $clean != "failed" ] && [ $clean != "none" ] ; then
-    echo Error: Invalid --clean value: $clean
+if [ "$clean" != "all" ] && [ "$clean" != "failed" ] && [ "$clean" != "none" ] ; then
+    echo Error: Invalid --clean value: "$clean"
     printUsage
     exit 1
 fi
@@ -138,8 +138,8 @@ if ! [ -e "$dbconv" ]; then
     exit 1
 fi
 
-if ! [ -n "$dst" ]; then
-    echo Error: Missing destination directory \(\-\-dst\)
+if [ -z "$dst" ]; then
+    echo "Error: Missing destination directory (--dst)"
     printUsage
     exit 1
 fi
@@ -168,9 +168,8 @@ fi
 
 if [ -e "$dst" ] && ! $skip_existing; then
     if $force; then
-        echo == Warning! Destination already exists, --force is set, removing all files under path: "$dst"
-        removeDir "$dst"
-        if [ $? -ne 0 ]; then
+        echo "== Warning! Destination already exists, --force is set, removing all files under path: $dst"
+        if ! removeDir "$dst"; then
             echo Error: failed to remove "$dst"
             exit 1
         fi
@@ -183,14 +182,13 @@ fi
 convert_result=
 convert () {
     srcdir="$src"/$1
-    dstdir=$(echo $dst/$1 | tr -s /)
-    if ! [ -e $dstdir ]; then
+    dstdir=$(echo "$dst"/"$1" | tr -s /)
+    if ! [ -e "$dstdir" ]; then
         echo "== Converting $1 db"
         cmd="$dbconv --src.db-engine=leveldb --src.data \"$srcdir\" --dst.db-engine=pebble --dst.data \"$dstdir\" --convert --compact"
-        echo $cmd
-        eval $cmd
-        if [ $? -ne 0 ]; then
-            cleanup $1
+        echo "$cmd"
+        if ! eval "$cmd"; then
+            cleanup "$1"
             convert_result="FAILED"
             return 1
         fi
@@ -221,9 +219,8 @@ if ! [ -e "$dst"/l2chaindata/ancient ]; then
     ancient_dst=$(echo "$dst"/l2chaindata/ | tr -s /)
     echo "== Copying l2chaindata ancients"
     cmd="cp -r \"$ancient_src\" \"$ancient_dst\""
-    echo $cmd
-    eval $cmd
-    if [ $? -ne 0 ]; then
+    echo "$cmd"
+    if ! eval "$cmd"; then
         l2chaindata_ancient_status="FAILED (failed to copy)"
         cleanup "l2chaindata"
         printStatus
@@ -249,7 +246,7 @@ if [ $res -ne 0 ]; then
     exit 1
 fi
 
-if [ -e $src/wasm ]; then
+if [ -e "$src"/wasm ]; then
     convert "wasm"
     res=$?
     wasm_status=$convert_result
@@ -262,7 +259,7 @@ else
     wasm_status="not found in source directory"
 fi
 
-if [ -e $src/classic-msg ]; then
+if [ -e "$src"/classic-msg ]; then
     convert "classic-msg"
     res=$?
     classicmsg_status=$convert_result
diff --git a/scripts/fuzz.bash b/scripts/fuzz.bash
index 6271b917b6..a73c208e88 100755
--- a/scripts/fuzz.bash
+++ b/scripts/fuzz.bash
@@ -2,12 +2,12 @@
 
 set -e
 
-mydir=`dirname $0`
+mydir=$(dirname "$0")
 cd "$mydir"
 
 function printusage {
-    echo Usage: $0 --build \[--binary-path PATH\]
-    echo "      "  $0 \<fuzzer-name\> \[--binary-path PATH\] \[--fuzzcache-path PATH\]  \[--nitro-path PATH\] \[--duration DURATION\]
+    echo Usage: "$0" --build \[--binary-path PATH\]
+    echo "      "  "$0" \<fuzzer-name\> \[--binary-path PATH\] \[--fuzzcache-path PATH\]  \[--nitro-path PATH\] \[--duration DURATION\]
     echo
     echo fuzzer names:
     echo "   " FuzzPrecompiles
@@ -22,7 +22,6 @@ if [[ $# -eq 0 ]]; then
     exit
 fi
 
-fuzz_executable=../target/bin/system_test.fuzz
 binpath=../target/bin/
 fuzzcachepath=../target/var/fuzz-cache
 nitropath=../
@@ -72,7 +71,7 @@ while [[ $# -gt 0 ]]; do
             shift
             ;;
         FuzzPrecompiles | FuzzStateTransition)
-            if [[ ! -z "$test_name" ]]; then
+            if [[ -n "$test_name" ]]; then
                 echo can only run one fuzzer at a time
                 exit 1
             fi
@@ -81,7 +80,7 @@ while [[ $# -gt 0 ]]; do
             shift
             ;;
         FuzzInboxMultiplexer)
-            if [[ ! -z "$test_name" ]]; then
+            if [[ -n "$test_name" ]]; then
                 echo can only run one fuzzer at a time
                 exit 1
             fi
@@ -102,17 +101,17 @@ fi
 
 if $run_build; then
     for build_group in system_tests arbstate; do
-        go test -c ${nitropath}/${build_group} -fuzz Fuzz -o "$binpath"/${build_group}.fuzz
+        go test -c "${nitropath}"/${build_group} -fuzz Fuzz -o "$binpath"/${build_group}.fuzz
     done
 fi
 
-if [[ ! -z $test_group ]]; then
-    timeout "$((60 * duration))" "$binpath"/${test_group}.fuzz -test.run "^$" -test.fuzzcachedir "$fuzzcachepath" -test.fuzz $test_name || exit_status=$?
+if [[ -n $test_group ]]; then
+    timeout "$((60 * duration))" "$binpath"/${test_group}.fuzz -test.run "^$" -test.fuzzcachedir "$fuzzcachepath" -test.fuzz "$test_name" || exit_status=$?
 fi
 
-if  [ -n "$exit_status" ] && [ $exit_status -ne 0 ] && [ $exit_status -ne 124 ]; then
+if  [ -n "$exit_status" ] && [ "$exit_status" -ne 0 ] && [ "$exit_status" -ne 124 ]; then
     echo "Fuzzing failed."
-    exit $exit_status
+    exit "$exit_status"
 fi
 
 echo "Fuzzing succeeded."
diff --git a/scripts/startup-testnode.bash b/scripts/startup-testnode.bash
index 701e7ff59a..5313a9ec5d 100755
--- a/scripts/startup-testnode.bash
+++ b/scripts/startup-testnode.bash
@@ -5,9 +5,9 @@
 
 timeout 60 ./nitro-testnode/test-node.bash --init --dev || exit_status=$?
 
-if  [ -n "$exit_status" ] && [ $exit_status -ne 0 ] && [ $exit_status -ne 124 ]; then
+if  [ -n "$exit_status" ] && [ "$exit_status" -ne 0 ] && [ "$exit_status" -ne 124 ]; then
     echo "Startup failed."
-    exit $exit_status
+    exit "$exit_status"
 fi
 
 echo "Startup succeeded."
diff --git a/staker/block_validator.go b/staker/block_validator.go
index 7a7efca846..5a1f123693 100644
--- a/staker/block_validator.go
+++ b/staker/block_validator.go
@@ -29,6 +29,8 @@ import (
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 	"github.com/offchainlabs/nitro/validator"
 	"github.com/offchainlabs/nitro/validator/client/redis"
+	"github.com/offchainlabs/nitro/validator/inputs"
+	"github.com/offchainlabs/nitro/validator/server_api"
 	"github.com/spf13/pflag"
 )
 
@@ -56,12 +58,12 @@ type BlockValidator struct {
 	chainCaughtUp bool
 
 	// can only be accessed from creation thread or if holding reorg-write
-	nextCreateBatch          []byte
-	nextCreateBatchBlockHash common.Hash
-	nextCreateBatchMsgCount  arbutil.MessageIndex
-	nextCreateBatchReread    bool
-	nextCreateStartGS        validator.GoGlobalState
-	nextCreatePrevDelayed    uint64
+	nextCreateBatch       *FullBatchInfo
+	nextCreateBatchReread bool
+	prevBatchCache        map[uint64][]byte
+
+	nextCreateStartGS     validator.GoGlobalState
+	nextCreatePrevDelayed uint64
 
 	// can only be accessed from from validation thread or if holding reorg-write
 	lastValidGS     validator.GoGlobalState
@@ -94,6 +96,9 @@ type BlockValidator struct {
 	// for testing only
 	testingProgressMadeChan chan struct{}
 
+	// For troubleshooting failed validations
+	validationInputsWriter *inputs.Writer
+
 	fatalErr chan<- error
 
 	MemoryFreeLimitChecker resourcemanager.LimitChecker
@@ -108,12 +113,16 @@ type BlockValidatorConfig struct {
 	PrerecordedBlocks           uint64                        `koanf:"prerecorded-blocks" reload:"hot"`
 	RecordingIterLimit          uint64                        `koanf:"recording-iter-limit"`
 	ForwardBlocks               uint64                        `koanf:"forward-blocks" reload:"hot"`
+	BatchCacheLimit             uint32                        `koanf:"batch-cache-limit"`
 	CurrentModuleRoot           string                        `koanf:"current-module-root"`         // TODO(magic) requires reinitialization on hot reload
 	PendingUpgradeModuleRoot    string                        `koanf:"pending-upgrade-module-root"` // TODO(magic) requires StatelessBlockValidator recreation on hot reload
 	FailureIsFatal              bool                          `koanf:"failure-is-fatal" reload:"hot"`
 	Dangerous                   BlockValidatorDangerousConfig `koanf:"dangerous"`
 	MemoryFreeLimit             string                        `koanf:"memory-free-limit" reload:"hot"`
 	ValidationServerConfigsList string                        `koanf:"validation-server-configs-list"`
+	// The directory to which the BlockValidator will write the
+	// block_inputs_<id>.json files when WriteToFile() is called.
+	BlockInputsFilePath string `koanf:"block-inputs-file-path"`
 
 	memoryFreeLimit int
 }
@@ -172,14 +181,16 @@ func BlockValidatorConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	redis.ValidationClientConfigAddOptions(prefix+".redis-validation-client-config", f)
 	f.String(prefix+".validation-server-configs-list", DefaultBlockValidatorConfig.ValidationServerConfigsList, "array of execution rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds")
 	f.Duration(prefix+".validation-poll", DefaultBlockValidatorConfig.ValidationPoll, "poll time to check validations")
-	f.Uint64(prefix+".forward-blocks", DefaultBlockValidatorConfig.ForwardBlocks, "prepare entries for up to that many blocks ahead of validation (small footprint)")
+	f.Uint64(prefix+".forward-blocks", DefaultBlockValidatorConfig.ForwardBlocks, "prepare entries for up to that many blocks ahead of validation (stores batch-copy per block)")
 	f.Uint64(prefix+".prerecorded-blocks", DefaultBlockValidatorConfig.PrerecordedBlocks, "record that many blocks ahead of validation (larger footprint)")
+	f.Uint32(prefix+".batch-cache-limit", DefaultBlockValidatorConfig.BatchCacheLimit, "limit number of old batches to keep in block-validator")
 	f.String(prefix+".current-module-root", DefaultBlockValidatorConfig.CurrentModuleRoot, "current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash)")
 	f.Uint64(prefix+".recording-iter-limit", DefaultBlockValidatorConfig.RecordingIterLimit, "limit on block recordings sent per iteration")
 	f.String(prefix+".pending-upgrade-module-root", DefaultBlockValidatorConfig.PendingUpgradeModuleRoot, "pending upgrade wasm module root to additionally validate (hash, 'latest' or empty)")
 	f.Bool(prefix+".failure-is-fatal", DefaultBlockValidatorConfig.FailureIsFatal, "failing a validation is treated as a fatal error")
 	BlockValidatorDangerousConfigAddOptions(prefix+".dangerous", f)
 	f.String(prefix+".memory-free-limit", DefaultBlockValidatorConfig.MemoryFreeLimit, "minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string")
+	f.String(prefix+".block-inputs-file-path", DefaultBlockValidatorConfig.BlockInputsFilePath, "directory to write block validation inputs files")
 }
 
 func BlockValidatorDangerousConfigAddOptions(prefix string, f *pflag.FlagSet) {
@@ -192,12 +203,14 @@ var DefaultBlockValidatorConfig = BlockValidatorConfig{
 	ValidationServer:            rpcclient.DefaultClientConfig,
 	RedisValidationClientConfig: redis.DefaultValidationClientConfig,
 	ValidationPoll:              time.Second,
-	ForwardBlocks:               1024,
+	ForwardBlocks:               128,
 	PrerecordedBlocks:           uint64(2 * runtime.NumCPU()),
+	BatchCacheLimit:             20,
 	CurrentModuleRoot:           "current",
 	PendingUpgradeModuleRoot:    "latest",
 	FailureIsFatal:              true,
 	Dangerous:                   DefaultBlockValidatorDangerousConfig,
+	BlockInputsFilePath:         "./target/validation_inputs",
 	MemoryFreeLimit:             "default",
 	RecordingIterLimit:          20,
 }
@@ -209,12 +222,14 @@ var TestBlockValidatorConfig = BlockValidatorConfig{
 	RedisValidationClientConfig: redis.TestValidationClientConfig,
 	ValidationPoll:              100 * time.Millisecond,
 	ForwardBlocks:               128,
+	BatchCacheLimit:             20,
 	PrerecordedBlocks:           uint64(2 * runtime.NumCPU()),
 	RecordingIterLimit:          20,
 	CurrentModuleRoot:           "latest",
 	PendingUpgradeModuleRoot:    "latest",
 	FailureIsFatal:              true,
 	Dangerous:                   DefaultBlockValidatorDangerousConfig,
+	BlockInputsFilePath:         "./target/validation_inputs",
 	MemoryFreeLimit:             "default",
 }
 
@@ -271,7 +286,15 @@ func NewBlockValidator(
 		progressValidationsChan: make(chan struct{}, 1),
 		config:                  config,
 		fatalErr:                fatalErr,
+		prevBatchCache:          make(map[uint64][]byte),
+	}
+	valInputsWriter, err := inputs.NewWriter(
+		inputs.WithBaseDir(ret.stack.InstanceDir()),
+		inputs.WithSlug("BlockValidator"))
+	if err != nil {
+		return nil, err
 	}
+	ret.validationInputsWriter = valInputsWriter
 	if !config().Dangerous.ResetBlockValidation {
 		validated, err := ret.ReadLastValidatedInfo()
 		if err != nil {
@@ -503,18 +526,16 @@ func (v *BlockValidator) sendRecord(s *validationStatus) error {
 }
 
 //nolint:gosec
-func (v *BlockValidator) writeToFile(validationEntry *validationEntry, moduleRoot common.Hash) error {
+func (v *BlockValidator) writeToFile(validationEntry *validationEntry) error {
 	input, err := validationEntry.ToInput([]ethdb.WasmTarget{rawdb.TargetWavm})
 	if err != nil {
 		return err
 	}
-	for _, spawner := range v.execSpawners {
-		if validator.SpawnerSupportsModule(spawner, moduleRoot) {
-			_, err = spawner.WriteToFile(input, validationEntry.End, moduleRoot).Await(v.GetContext())
-			return err
-		}
+	inputJson := server_api.ValidationInputToJson(input)
+	if err := v.validationInputsWriter.Write(inputJson); err != nil {
+		return err
 	}
-	return errors.New("did not find exec spawner for wasmModuleRoot")
+	return nil
 }
 
 func (v *BlockValidator) SetCurrentWasmModuleRoot(hash common.Hash) error {
@@ -571,33 +592,63 @@ func (v *BlockValidator) createNextValidationEntry(ctx context.Context) (bool, e
 	}
 	if v.nextCreateStartGS.PosInBatch == 0 || v.nextCreateBatchReread {
 		// new batch
-		found, batch, batchBlockHash, count, err := v.readBatch(ctx, v.nextCreateStartGS.Batch)
+		found, fullBatchInfo, err := v.readFullBatch(ctx, v.nextCreateStartGS.Batch)
 		if !found {
 			return false, err
 		}
-		v.nextCreateBatch = batch
-		v.nextCreateBatchBlockHash = batchBlockHash
-		v.nextCreateBatchMsgCount = count
+		if v.nextCreateBatch != nil {
+			v.prevBatchCache[v.nextCreateBatch.Number] = v.nextCreateBatch.PostedData
+		}
+		v.nextCreateBatch = fullBatchInfo
 		// #nosec G115
-		validatorMsgCountCurrentBatch.Update(int64(count))
+		validatorMsgCountCurrentBatch.Update(int64(fullBatchInfo.MsgCount))
+		batchCacheLimit := v.config().BatchCacheLimit
+		if len(v.prevBatchCache) > int(batchCacheLimit) {
+			for num := range v.prevBatchCache {
+				if num+uint64(batchCacheLimit) < v.nextCreateStartGS.Batch {
+					delete(v.prevBatchCache, num)
+				}
+			}
+		}
 		v.nextCreateBatchReread = false
 	}
 	endGS := validator.GoGlobalState{
 		BlockHash: endRes.BlockHash,
 		SendRoot:  endRes.SendRoot,
 	}
-	if pos+1 < v.nextCreateBatchMsgCount {
+	if pos+1 < v.nextCreateBatch.MsgCount {
 		endGS.Batch = v.nextCreateStartGS.Batch
 		endGS.PosInBatch = v.nextCreateStartGS.PosInBatch + 1
-	} else if pos+1 == v.nextCreateBatchMsgCount {
+	} else if pos+1 == v.nextCreateBatch.MsgCount {
 		endGS.Batch = v.nextCreateStartGS.Batch + 1
 		endGS.PosInBatch = 0
 	} else {
-		return false, fmt.Errorf("illegal batch msg count %d pos %d batch %d", v.nextCreateBatchMsgCount, pos, endGS.Batch)
+		return false, fmt.Errorf("illegal batch msg count %d pos %d batch %d", v.nextCreateBatch.MsgCount, pos, endGS.Batch)
 	}
 	chainConfig := v.streamer.ChainConfig()
+	prevBatchNums, err := msg.Message.PastBatchesRequired()
+	if err != nil {
+		return false, err
+	}
+	prevBatches := make([]validator.BatchInfo, 0, len(prevBatchNums))
+	// prevBatchNums are only used for batch reports, each is only used once
+	for _, batchNum := range prevBatchNums {
+		data, found := v.prevBatchCache[batchNum]
+		if found {
+			delete(v.prevBatchCache, batchNum)
+		} else {
+			data, err = v.readPostedBatch(ctx, batchNum)
+			if err != nil {
+				return false, err
+			}
+		}
+		prevBatches = append(prevBatches, validator.BatchInfo{
+			Number: batchNum,
+			Data:   data,
+		})
+	}
 	entry, err := newValidationEntry(
-		pos, v.nextCreateStartGS, endGS, msg, v.nextCreateBatch, v.nextCreateBatchBlockHash, v.nextCreatePrevDelayed, chainConfig,
+		pos, v.nextCreateStartGS, endGS, msg, v.nextCreateBatch, prevBatches, v.nextCreatePrevDelayed, chainConfig,
 	)
 	if err != nil {
 		return false, err
@@ -788,7 +839,7 @@ validationsLoop:
 				runEnd, err := run.Current()
 				if err == nil && runEnd != validationStatus.Entry.End {
 					err = fmt.Errorf("validation failed: expected %v got %v", validationStatus.Entry.End, runEnd)
-					writeErr := v.writeToFile(validationStatus.Entry, run.WasmModuleRoot())
+					writeErr := v.writeToFile(validationStatus.Entry)
 					if writeErr != nil {
 						log.Warn("failed to write debug results file", "err", writeErr)
 					}
@@ -997,6 +1048,9 @@ func (v *BlockValidator) UpdateLatestStaked(count arbutil.MessageIndex, globalSt
 		v.nextCreateStartGS = globalState
 		v.nextCreatePrevDelayed = msg.DelayedMessagesRead
 		v.nextCreateBatchReread = true
+		if v.nextCreateBatch != nil {
+			v.prevBatchCache[v.nextCreateBatch.Number] = v.nextCreateBatch.PostedData
+		}
 		v.createdA.Store(countUint64)
 	}
 	// under the reorg mutex we don't need atomic access
@@ -1023,6 +1077,7 @@ func (v *BlockValidator) ReorgToBatchCount(count uint64) {
 	defer v.reorgMutex.Unlock()
 	if v.nextCreateStartGS.Batch >= count {
 		v.nextCreateBatchReread = true
+		v.prevBatchCache = make(map[uint64][]byte)
 	}
 }
 
@@ -1063,6 +1118,7 @@ func (v *BlockValidator) Reorg(ctx context.Context, count arbutil.MessageIndex)
 	v.nextCreateStartGS = buildGlobalState(*res, endPosition)
 	v.nextCreatePrevDelayed = msg.DelayedMessagesRead
 	v.nextCreateBatchReread = true
+	v.prevBatchCache = make(map[uint64][]byte)
 	countUint64 := uint64(count)
 	v.createdA.Store(countUint64)
 	// under the reorg mutex we don't need atomic access
diff --git a/staker/fast_confirm.go b/staker/fast_confirm.go
index 88f457f528..5dc7f01205 100644
--- a/staker/fast_confirm.go
+++ b/staker/fast_confirm.go
@@ -121,10 +121,12 @@ func (f *FastConfirmSafe) tryFastConfirmation(ctx context.Context, blockHash com
 		return err
 	}
 	if alreadyApproved.Cmp(common.Big1) == 0 {
+		log.Info("Already approved Safe tx hash for fast confirmation, checking if we can execute the Safe tx", "safeHash", safeTxHash, "nodeHash", nodeHash)
 		_, err = f.checkApprovedHashAndExecTransaction(ctx, fastConfirmCallData, safeTxHash)
 		return err
 	}
 
+	log.Info("Approving Safe tx hash to fast confirm", "safeHash", safeTxHash, "nodeHash", nodeHash)
 	auth, err := f.builder.Auth(ctx)
 	if err != nil {
 		return err
@@ -231,6 +233,7 @@ func (f *FastConfirmSafe) checkApprovedHashAndExecTransaction(ctx context.Contex
 		if err != nil {
 			return false, err
 		}
+		log.Info("Executing Safe tx to fast confirm", "safeHash", safeTxHash)
 		_, err = f.safe.ExecTransaction(
 			auth,
 			f.wallet.RollupAddress(),
@@ -249,5 +252,6 @@ func (f *FastConfirmSafe) checkApprovedHashAndExecTransaction(ctx context.Contex
 		}
 		return true, nil
 	}
+	log.Info("Not enough Safe tx approvals yet to fast confirm", "safeHash", safeTxHash)
 	return false, nil
 }
diff --git a/staker/staker.go b/staker/staker.go
index 1d49063a89..2489bbbcf7 100644
--- a/staker/staker.go
+++ b/staker/staker.go
@@ -269,7 +269,6 @@ type Staker struct {
 	inboxReader             InboxReaderInterface
 	statelessBlockValidator *StatelessBlockValidator
 	fatalErr                chan<- error
-	enableFastConfirmation  bool
 	fastConfirmSafe         *FastConfirmSafe
 }
 
@@ -364,7 +363,10 @@ func (s *Staker) Initialize(ctx context.Context) error {
 			return err
 		}
 
-		return s.blockValidator.InitAssumeValid(stakedInfo.AfterState().GlobalState)
+		err = s.blockValidator.InitAssumeValid(stakedInfo.AfterState().GlobalState)
+		if err != nil {
+			return err
+		}
 	}
 	return s.setupFastConfirmation(ctx)
 }
@@ -391,9 +393,9 @@ func (s *Staker) setupFastConfirmation(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("getting rollup fast confirmer address: %w", err)
 	}
+	log.Info("Setting up fast confirmation", "wallet", walletAddress, "fastConfirmer", fastConfirmer)
 	if fastConfirmer == walletAddress {
 		// We can directly fast confirm nodes
-		s.enableFastConfirmation = true
 		return nil
 	} else if fastConfirmer == (common.Address{}) {
 		// No fast confirmer enabled
@@ -420,13 +422,12 @@ func (s *Staker) setupFastConfirmation(ctx context.Context) error {
 	if !isOwner {
 		return fmt.Errorf("staker wallet address %v is not an owner of the fast confirm safe %v", walletAddress, fastConfirmer)
 	}
-	s.enableFastConfirmation = true
 	s.fastConfirmSafe = fastConfirmSafe
 	return nil
 }
 
 func (s *Staker) tryFastConfirmationNodeNumber(ctx context.Context, number uint64, hash common.Hash) error {
-	if !s.enableFastConfirmation {
+	if !s.config().EnableFastConfirmation {
 		return nil
 	}
 	nodeInfo, err := s.rollup.LookupNode(ctx, number)
@@ -437,7 +438,7 @@ func (s *Staker) tryFastConfirmationNodeNumber(ctx context.Context, number uint6
 }
 
 func (s *Staker) tryFastConfirmation(ctx context.Context, blockHash common.Hash, sendRoot common.Hash, nodeHash common.Hash) error {
-	if !s.enableFastConfirmation {
+	if !s.config().EnableFastConfirmation {
 		return nil
 	}
 	if s.fastConfirmSafe != nil {
@@ -447,6 +448,7 @@ func (s *Staker) tryFastConfirmation(ctx context.Context, blockHash common.Hash,
 	if err != nil {
 		return err
 	}
+	log.Info("Fast confirming node with wallet", "wallet", auth.From, "nodeHash", nodeHash)
 	_, err = s.rollup.FastConfirmNextNode(auth, blockHash, sendRoot, nodeHash)
 	return err
 }
@@ -803,13 +805,13 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 				confirmedCorrect = stakedOnNode
 			}
 			if confirmedCorrect {
+				log.Info("trying to fast confirm previous node", "node", firstUnresolvedNode, "nodeHash", nodeInfo.NodeHash)
 				err = s.tryFastConfirmationNodeNumber(ctx, firstUnresolvedNode, nodeInfo.NodeHash)
 				if err != nil {
 					return nil, err
 				}
 				if s.builder.BuildingTransactionCount() > 0 {
 					// Try to fast confirm previous nodes before working on new ones
-					log.Info("fast confirming previous node", "node", firstUnresolvedNode)
 					return s.wallet.ExecuteTransactions(ctx, s.builder, cfg.gasRefunder)
 				}
 			}
diff --git a/staker/stateless_block_validator.go b/staker/stateless_block_validator.go
index f54ec8b58c..9257c5582a 100644
--- a/staker/stateless_block_validator.go
+++ b/staker/stateless_block_validator.go
@@ -23,6 +23,7 @@ import (
 	"github.com/offchainlabs/nitro/util/rpcclient"
 	"github.com/offchainlabs/nitro/validator"
 	"github.com/offchainlabs/nitro/validator/client/redis"
+	"github.com/offchainlabs/nitro/validator/server_api"
 
 	validatorclient "github.com/offchainlabs/nitro/validator/client"
 )
@@ -40,6 +41,7 @@ type StatelessBlockValidator struct {
 	streamer     TransactionStreamerInterface
 	db           ethdb.Database
 	dapReaders   []daprovider.Reader
+	stack        *node.Node
 }
 
 type BlockValidatorRegistrer interface {
@@ -114,6 +116,13 @@ const (
 	Ready
 )
 
+type FullBatchInfo struct {
+	Number     uint64
+	PostedData []byte
+	MsgCount   arbutil.MessageIndex
+	Preimages  map[arbutil.PreimageType]map[common.Hash][]byte
+}
+
 type validationEntry struct {
 	Stage ValidationEntryStage
 	// Valid since ReadyforRecord:
@@ -171,16 +180,28 @@ func newValidationEntry(
 	start validator.GoGlobalState,
 	end validator.GoGlobalState,
 	msg *arbostypes.MessageWithMetadata,
-	batch []byte,
-	batchBlockHash common.Hash,
+	fullBatchInfo *FullBatchInfo,
+	prevBatches []validator.BatchInfo,
 	prevDelayed uint64,
 	chainConfig *params.ChainConfig,
 ) (*validationEntry, error) {
-	batchInfo := validator.BatchInfo{
-		Number:    start.Batch,
-		BlockHash: batchBlockHash,
-		Data:      batch,
+	preimages := make(map[arbutil.PreimageType]map[common.Hash][]byte)
+	if fullBatchInfo == nil {
+		return nil, fmt.Errorf("fullbatchInfo cannot be nil")
 	}
+	if fullBatchInfo.Number != start.Batch {
+		return nil, fmt.Errorf("got wrong batch expected: %d got: %d", start.Batch, fullBatchInfo.Number)
+	}
+	valBatches := []validator.BatchInfo{
+		{
+			Number: fullBatchInfo.Number,
+			Data:   fullBatchInfo.PostedData,
+		},
+	}
+	valBatches = append(valBatches, prevBatches...)
+
+	copyPreimagesInto(preimages, fullBatchInfo.Preimages)
+
 	hasDelayed := false
 	var delayedNum uint64
 	if msg.DelayedMessagesRead == prevDelayed+1 {
@@ -189,6 +210,7 @@ func newValidationEntry(
 	} else if msg.DelayedMessagesRead != prevDelayed {
 		return nil, fmt.Errorf("illegal validation entry delayedMessage %d, previous %d", msg.DelayedMessagesRead, prevDelayed)
 	}
+
 	return &validationEntry{
 		Stage:         ReadyForRecord,
 		Pos:           pos,
@@ -197,8 +219,9 @@ func newValidationEntry(
 		HasDelayedMsg: hasDelayed,
 		DelayedMsgNr:  delayedNum,
 		msg:           msg,
-		BatchInfo:     []validator.BatchInfo{batchInfo},
+		BatchInfo:     valBatches,
 		ChainConfig:   chainConfig,
+		Preimages:     preimages,
 	}, nil
 }
 
@@ -243,33 +266,88 @@ func NewStatelessBlockValidator(
 		db:             arbdb,
 		dapReaders:     dapReaders,
 		execSpawners:   executionSpawners,
+		stack:          stack,
 	}, nil
 }
 
-func (v *StatelessBlockValidator) readBatch(ctx context.Context, batchNum uint64) (bool, []byte, common.Hash, arbutil.MessageIndex, error) {
+func (v *StatelessBlockValidator) readPostedBatch(ctx context.Context, batchNum uint64) ([]byte, error) {
+	batchCount, err := v.inboxTracker.GetBatchCount()
+	if err != nil {
+		return nil, err
+	}
+	if batchCount <= batchNum {
+		return nil, fmt.Errorf("batch not found: %d", batchNum)
+	}
+	postedData, _, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+	return postedData, err
+}
+
+func (v *StatelessBlockValidator) readFullBatch(ctx context.Context, batchNum uint64) (bool, *FullBatchInfo, error) {
 	batchCount, err := v.inboxTracker.GetBatchCount()
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return false, nil, err
 	}
 	if batchCount <= batchNum {
-		return false, nil, common.Hash{}, 0, nil
+		return false, nil, nil
 	}
 	batchMsgCount, err := v.inboxTracker.GetBatchMessageCount(batchNum)
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return false, nil, err
 	}
-	batch, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+	postedData, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return false, nil, err
+	}
+	preimages := make(map[arbutil.PreimageType]map[common.Hash][]byte)
+	if len(postedData) > 40 {
+		foundDA := false
+		for _, dapReader := range v.dapReaders {
+			if dapReader != nil && dapReader.IsValidHeaderByte(postedData[40]) {
+				preimageRecorder := daprovider.RecordPreimagesTo(preimages)
+				_, err := dapReader.RecoverPayloadFromBatch(ctx, batchNum, batchBlockHash, postedData, preimageRecorder, true)
+				if err != nil {
+					// Matches the way keyset validation was done inside DAS readers i.e logging the error
+					//  But other daproviders might just want to return the error
+					if errors.Is(err, daprovider.ErrSeqMsgValidation) && daprovider.IsDASMessageHeaderByte(postedData[40]) {
+						log.Error(err.Error())
+					} else {
+						return false, nil, err
+					}
+				}
+				foundDA = true
+				break
+			}
+		}
+		if !foundDA {
+			if daprovider.IsDASMessageHeaderByte(postedData[40]) {
+				log.Error("No DAS Reader configured, but sequencer message found with DAS header")
+			}
+		}
+	}
+	fullInfo := FullBatchInfo{
+		Number:     batchNum,
+		PostedData: postedData,
+		MsgCount:   batchMsgCount,
+		Preimages:  preimages,
+	}
+	return true, &fullInfo, nil
+}
+
+func copyPreimagesInto(dest, source map[arbutil.PreimageType]map[common.Hash][]byte) {
+	for piType, piMap := range source {
+		if dest[piType] == nil {
+			dest[piType] = make(map[common.Hash][]byte, len(piMap))
+		}
+		for hash, preimage := range piMap {
+			dest[piType][hash] = preimage
+		}
 	}
-	return true, batch, batchBlockHash, batchMsgCount, nil
 }
 
 func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *validationEntry) error {
 	if e.Stage != ReadyForRecord {
 		return fmt.Errorf("validation entry should be ReadyForRecord, is: %v", e.Stage)
 	}
-	e.Preimages = make(map[arbutil.PreimageType]map[common.Hash][]byte)
 	if e.Pos != 0 {
 		recording, err := v.recorder.RecordBlockCreation(ctx, e.Pos, e.msg)
 		if err != nil {
@@ -278,30 +356,11 @@ func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *
 		if recording.BlockHash != e.End.BlockHash {
 			return fmt.Errorf("recording failed: pos %d, hash expected %v, got %v", e.Pos, e.End.BlockHash, recording.BlockHash)
 		}
-		// record any additional batch fetching
-		batchFetcher := func(batchNum uint64) ([]byte, error) {
-			found, data, hash, _, err := v.readBatch(ctx, batchNum)
-			if err != nil {
-				return nil, err
-			}
-			if !found {
-				return nil, errors.New("batch not found")
-			}
-			e.BatchInfo = append(e.BatchInfo, validator.BatchInfo{
-				Number:    batchNum,
-				BlockHash: hash,
-				Data:      data,
-			})
-			return data, nil
-		}
-		e.msg.Message.BatchGasCost = nil
-		err = e.msg.Message.FillInBatchGasCost(batchFetcher)
-		if err != nil {
-			return err
-		}
-
 		if recording.Preimages != nil {
-			e.Preimages[arbutil.Keccak256PreimageType] = recording.Preimages
+			recordingPreimages := map[arbutil.PreimageType]map[common.Hash][]byte{
+				arbutil.Keccak256PreimageType: recording.Preimages,
+			}
+			copyPreimagesInto(e.Preimages, recordingPreimages)
 		}
 		e.UserWasms = recording.UserWasms
 	}
@@ -316,35 +375,6 @@ func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *
 		}
 		e.DelayedMsg = delayedMsg
 	}
-	for _, batch := range e.BatchInfo {
-		if len(batch.Data) <= 40 {
-			continue
-		}
-		foundDA := false
-		for _, dapReader := range v.dapReaders {
-			if dapReader != nil && dapReader.IsValidHeaderByte(batch.Data[40]) {
-				preimageRecorder := daprovider.RecordPreimagesTo(e.Preimages)
-				_, err := dapReader.RecoverPayloadFromBatch(ctx, batch.Number, batch.BlockHash, batch.Data, preimageRecorder, true)
-				if err != nil {
-					// Matches the way keyset validation was done inside DAS readers i.e logging the error
-					//  But other daproviders might just want to return the error
-					if errors.Is(err, daprovider.ErrSeqMsgValidation) && daprovider.IsDASMessageHeaderByte(batch.Data[40]) {
-						log.Error(err.Error())
-					} else {
-						return err
-					}
-				}
-				foundDA = true
-				break
-			}
-		}
-		if !foundDA {
-			if daprovider.IsDASMessageHeaderByte(batch.Data[40]) {
-				log.Error("No DAS Reader configured, but sequencer message found with DAS header")
-			}
-		}
-	}
-
 	e.msg = nil // no longer needed
 	e.Stage = Ready
 	return nil
@@ -404,11 +434,30 @@ func (v *StatelessBlockValidator) CreateReadyValidationEntry(ctx context.Context
 	}
 	start := buildGlobalState(*prevResult, startPos)
 	end := buildGlobalState(*result, endPos)
-	seqMsg, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, startPos.BatchNumber)
+	found, fullBatchInfo, err := v.readFullBatch(ctx, start.Batch)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, fmt.Errorf("batch %d not found", startPos.BatchNumber)
+	}
+
+	prevBatchNums, err := msg.Message.PastBatchesRequired()
 	if err != nil {
 		return nil, err
 	}
-	entry, err := newValidationEntry(pos, start, end, msg, seqMsg, batchBlockHash, prevDelayed, v.streamer.ChainConfig())
+	prevBatches := make([]validator.BatchInfo, 0, len(prevBatchNums))
+	for _, batchNum := range prevBatchNums {
+		data, err := v.readPostedBatch(ctx, batchNum)
+		if err != nil {
+			return nil, err
+		}
+		prevBatches = append(prevBatches, validator.BatchInfo{
+			Number: batchNum,
+			Data:   data,
+		})
+	}
+	entry, err := newValidationEntry(pos, start, end, msg, fullBatchInfo, prevBatches, prevDelayed, v.streamer.ChainConfig())
 	if err != nil {
 		return nil, err
 	}
@@ -462,6 +511,18 @@ func (v *StatelessBlockValidator) ValidateResult(
 	return true, &entry.End, nil
 }
 
+func (v *StatelessBlockValidator) ValidationInputsAt(ctx context.Context, pos arbutil.MessageIndex, target ethdb.WasmTarget) (server_api.InputJSON, error) {
+	entry, err := v.CreateReadyValidationEntry(ctx, pos)
+	if err != nil {
+		return server_api.InputJSON{}, err
+	}
+	input, err := entry.ToInput([]ethdb.WasmTarget{target})
+	if err != nil {
+		return server_api.InputJSON{}, err
+	}
+	return *server_api.ValidationInputToJson(input), nil
+}
+
 func (v *StatelessBlockValidator) OverrideRecorder(t *testing.T, recorder execution.ExecutionRecorder) {
 	v.recorder = recorder
 }
diff --git a/system_tests/block_validator_test.go b/system_tests/block_validator_test.go
index cca5572f4e..9125c3921e 100644
--- a/system_tests/block_validator_test.go
+++ b/system_tests/block_validator_test.go
@@ -284,6 +284,20 @@ func TestBlockValidatorSimpleOnchain(t *testing.T) {
 	testBlockValidatorSimple(t, opts)
 }
 
+func TestBlockValidatorSimpleJITOnchainWithPublishedMachine(t *testing.T) {
+	cr, err := github.LatestConsensusRelease(context.Background())
+	Require(t, err)
+	machPath := populateMachineDir(t, cr)
+	opts := Options{
+		dasModeString: "onchain",
+		workloadLoops: 1,
+		workload:      ethSend,
+		arbitrator:    false,
+		wasmRootDir:   machPath,
+	}
+	testBlockValidatorSimple(t, opts)
+}
+
 func TestBlockValidatorSimpleOnchainWithPublishedMachine(t *testing.T) {
 	cr, err := github.LatestConsensusRelease(context.Background())
 	Require(t, err)
diff --git a/system_tests/common_test.go b/system_tests/common_test.go
index 0481449338..67bc01c92d 100644
--- a/system_tests/common_test.go
+++ b/system_tests/common_test.go
@@ -25,6 +25,7 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
+	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/blsSignatures"
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/conf"
@@ -36,6 +37,7 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 	"github.com/offchainlabs/nitro/util/redisutil"
 	"github.com/offchainlabs/nitro/util/signature"
+	"github.com/offchainlabs/nitro/validator/inputs"
 	"github.com/offchainlabs/nitro/validator/server_api"
 	"github.com/offchainlabs/nitro/validator/server_common"
 	"github.com/offchainlabs/nitro/validator/valnode"
@@ -164,7 +166,7 @@ var TestCachingConfig = gethexec.CachingConfig{
 	SnapshotRestoreGasLimit:            300_000_000_000,
 	MaxNumberOfBlocksToSkipStateSaving: 0,
 	MaxAmountOfGasToSkipStateSaving:    0,
-	StylusLRUCache:                     0,
+	StylusLRUCacheCapacity:             0,
 	StateScheme:                        env.GetTestStateScheme(),
 }
 
@@ -231,21 +233,73 @@ type NodeBuilder struct {
 	l1StackConfig *node.Config
 	l2StackConfig *node.Config
 	valnodeConfig *valnode.Config
+	l3Config      *NitroConfig
 	L1Info        info
 	L2Info        info
+	L3Info        info
 
-	// L1, L2 Node parameters
+	// L1, L2, L3 Node parameters
 	dataDir                     string
 	isSequencer                 bool
 	takeOwnership               bool
 	withL1                      bool
 	addresses                   *chaininfo.RollupAddresses
+	l3Addresses                 *chaininfo.RollupAddresses
 	initMessage                 *arbostypes.ParsedInitMessage
+	l3InitMessage               *arbostypes.ParsedInitMessage
 	withProdConfirmPeriodBlocks bool
 
 	// Created nodes
 	L1 *TestClient
 	L2 *TestClient
+	L3 *TestClient
+}
+
+type NitroConfig struct {
+	chainConfig   *params.ChainConfig
+	nodeConfig    *arbnode.Config
+	execConfig    *gethexec.Config
+	stackConfig   *node.Config
+	valnodeConfig *valnode.Config
+
+	withProdConfirmPeriodBlocks bool
+	isSequencer                 bool
+}
+
+func L3NitroConfigDefaultTest(t *testing.T) *NitroConfig {
+	chainConfig := &params.ChainConfig{
+		ChainID:             big.NewInt(333333),
+		HomesteadBlock:      big.NewInt(0),
+		DAOForkBlock:        nil,
+		DAOForkSupport:      true,
+		EIP150Block:         big.NewInt(0),
+		EIP155Block:         big.NewInt(0),
+		EIP158Block:         big.NewInt(0),
+		ByzantiumBlock:      big.NewInt(0),
+		ConstantinopleBlock: big.NewInt(0),
+		PetersburgBlock:     big.NewInt(0),
+		IstanbulBlock:       big.NewInt(0),
+		MuirGlacierBlock:    big.NewInt(0),
+		BerlinBlock:         big.NewInt(0),
+		LondonBlock:         big.NewInt(0),
+		ArbitrumChainParams: params.ArbitrumDevTestParams(),
+		Clique: &params.CliqueConfig{
+			Period: 0,
+			Epoch:  0,
+		},
+	}
+
+	valnodeConfig := valnode.TestValidationConfig
+	return &NitroConfig{
+		chainConfig:   chainConfig,
+		nodeConfig:    arbnode.ConfigDefaultL1Test(),
+		execConfig:    ExecConfigDefaultTest(t),
+		stackConfig:   testhelpers.CreateStackConfigForTest(t.TempDir()),
+		valnodeConfig: &valnodeConfig,
+
+		withProdConfirmPeriodBlocks: false,
+		isSequencer:                 true,
+	}
 }
 
 func NewNodeBuilder(ctx context.Context) *NodeBuilder {
@@ -271,6 +325,7 @@ func (b *NodeBuilder) DefaultConfig(t *testing.T, withL1 bool) *NodeBuilder {
 	cp := valnode.TestValidationConfig
 	b.valnodeConfig = &cp
 	b.execConfig = ExecConfigDefaultTest(t)
+	b.l3Config = L3NitroConfigDefaultTest(t)
 	return b
 }
 
@@ -335,64 +390,169 @@ func (b *NodeBuilder) BuildL1(t *testing.T) {
 	b.L1Info, b.L1.Client, b.L1.L1Backend, b.L1.Stack = createTestL1BlockChain(t, b.L1Info)
 	locator, err := server_common.NewMachineLocator(b.valnodeConfig.Wasm.RootPath)
 	Require(t, err)
-	b.addresses, b.initMessage = DeployOnTestL1(t, b.ctx, b.L1Info, b.L1.Client, b.chainConfig, locator.LatestWasmModuleRoot(), b.withProdConfirmPeriodBlocks)
+	b.addresses, b.initMessage = deployOnParentChain(
+		t,
+		b.ctx,
+		b.L1Info,
+		b.L1.Client,
+		&headerreader.TestConfig,
+		b.chainConfig,
+		locator.LatestWasmModuleRoot(),
+		b.withProdConfirmPeriodBlocks,
+		true,
+	)
 	b.L1.cleanup = func() { requireClose(t, b.L1.Stack) }
 }
 
-func (b *NodeBuilder) BuildL2OnL1(t *testing.T) func() {
-	if b.L1 == nil {
-		t.Fatal("must build L1 before building L2")
+func buildOnParentChain(
+	t *testing.T,
+	ctx context.Context,
+
+	dataDir string,
+
+	parentChainInfo info,
+	parentChainTestClient *TestClient,
+	parentChainId *big.Int,
+
+	chainConfig *params.ChainConfig,
+	stackConfig *node.Config,
+	execConfig *gethexec.Config,
+	nodeConfig *arbnode.Config,
+	valnodeConfig *valnode.Config,
+	isSequencer bool,
+	chainInfo info,
+
+	initMessage *arbostypes.ParsedInitMessage,
+	addresses *chaininfo.RollupAddresses,
+) *TestClient {
+	if parentChainTestClient == nil {
+		t.Fatal("must build parent chain before building chain")
 	}
-	b.L2 = NewTestClient(b.ctx)
 
-	var l2chainDb ethdb.Database
-	var l2arbDb ethdb.Database
-	var l2blockchain *core.BlockChain
-	_, b.L2.Stack, l2chainDb, l2arbDb, l2blockchain = createL2BlockChainWithStackConfig(
-		t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, b.execConfig)
+	chainTestClient := NewTestClient(ctx)
+
+	var chainDb ethdb.Database
+	var arbDb ethdb.Database
+	var blockchain *core.BlockChain
+	_, chainTestClient.Stack, chainDb, arbDb, blockchain = createNonL1BlockChainWithStackConfig(
+		t, chainInfo, dataDir, chainConfig, initMessage, stackConfig, execConfig)
 
 	var sequencerTxOptsPtr *bind.TransactOpts
 	var dataSigner signature.DataSignerFunc
-	if b.isSequencer {
-		sequencerTxOpts := b.L1Info.GetDefaultTransactOpts("Sequencer", b.ctx)
+	if isSequencer {
+		sequencerTxOpts := parentChainInfo.GetDefaultTransactOpts("Sequencer", ctx)
 		sequencerTxOptsPtr = &sequencerTxOpts
-		dataSigner = signature.DataSignerFromPrivateKey(b.L1Info.GetInfoWithPrivKey("Sequencer").PrivateKey)
+		dataSigner = signature.DataSignerFromPrivateKey(parentChainInfo.GetInfoWithPrivKey("Sequencer").PrivateKey)
 	} else {
-		b.nodeConfig.BatchPoster.Enable = false
-		b.nodeConfig.Sequencer = false
-		b.nodeConfig.DelayedSequencer.Enable = false
-		b.execConfig.Sequencer.Enable = false
+		nodeConfig.BatchPoster.Enable = false
+		nodeConfig.Sequencer = false
+		nodeConfig.DelayedSequencer.Enable = false
+		execConfig.Sequencer.Enable = false
 	}
 
 	var validatorTxOptsPtr *bind.TransactOpts
-	if b.nodeConfig.Staker.Enable {
-		validatorTxOpts := b.L1Info.GetDefaultTransactOpts("Validator", b.ctx)
+	if nodeConfig.Staker.Enable {
+		validatorTxOpts := parentChainInfo.GetDefaultTransactOpts("Validator", ctx)
 		validatorTxOptsPtr = &validatorTxOpts
 	}
 
-	AddValNodeIfNeeded(t, b.ctx, b.nodeConfig, true, "", b.valnodeConfig.Wasm.RootPath)
+	AddValNodeIfNeeded(t, ctx, nodeConfig, true, "", valnodeConfig.Wasm.RootPath)
 
-	Require(t, b.execConfig.Validate())
-	execConfig := b.execConfig
-	execConfigFetcher := func() *gethexec.Config { return execConfig }
-	execNode, err := gethexec.CreateExecutionNode(b.ctx, b.L2.Stack, l2chainDb, l2blockchain, b.L1.Client, execConfigFetcher)
+	Require(t, execConfig.Validate())
+	execConfigToBeUsedInConfigFetcher := execConfig
+	execConfigFetcher := func() *gethexec.Config { return execConfigToBeUsedInConfigFetcher }
+	execNode, err := gethexec.CreateExecutionNode(ctx, chainTestClient.Stack, chainDb, blockchain, parentChainTestClient.Client, execConfigFetcher)
 	Require(t, err)
 
 	fatalErrChan := make(chan error, 10)
-	b.L2.ConsensusNode, err = arbnode.CreateNode(
-		b.ctx, b.L2.Stack, execNode, l2arbDb, NewFetcherFromConfig(b.nodeConfig), l2blockchain.Config(), b.L1.Client,
-		b.addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, big.NewInt(1337), nil)
+	chainTestClient.ConsensusNode, err = arbnode.CreateNode(
+		ctx, chainTestClient.Stack, execNode, arbDb, NewFetcherFromConfig(nodeConfig), blockchain.Config(), parentChainTestClient.Client,
+		addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, parentChainId, nil)
 	Require(t, err)
 
-	err = b.L2.ConsensusNode.Start(b.ctx)
+	err = chainTestClient.ConsensusNode.Start(ctx)
 	Require(t, err)
 
-	b.L2.Client = ClientForStack(t, b.L2.Stack)
+	chainTestClient.Client = ClientForStack(t, chainTestClient.Stack)
 
-	StartWatchChanErr(t, b.ctx, fatalErrChan, b.L2.ConsensusNode)
+	StartWatchChanErr(t, ctx, fatalErrChan, chainTestClient.ConsensusNode)
+
+	chainTestClient.ExecNode = getExecNode(t, chainTestClient.ConsensusNode)
+	chainTestClient.cleanup = func() { chainTestClient.ConsensusNode.StopAndWait() }
+
+	return chainTestClient
+}
+
+func (b *NodeBuilder) BuildL3OnL2(t *testing.T) func() {
+	b.L3Info = NewArbTestInfo(t, b.l3Config.chainConfig.ChainID)
+
+	locator, err := server_common.NewMachineLocator(b.l3Config.valnodeConfig.Wasm.RootPath)
+	Require(t, err)
+
+	parentChainReaderConfig := headerreader.TestConfig
+	parentChainReaderConfig.Dangerous.WaitForTxApprovalSafePoll = 0
+	b.l3Addresses, b.l3InitMessage = deployOnParentChain(
+		t,
+		b.ctx,
+		b.L2Info,
+		b.L2.Client,
+		&parentChainReaderConfig,
+		b.l3Config.chainConfig,
+		locator.LatestWasmModuleRoot(),
+		b.l3Config.withProdConfirmPeriodBlocks,
+		false,
+	)
+
+	b.L3 = buildOnParentChain(
+		t,
+		b.ctx,
+
+		b.dataDir,
+
+		b.L2Info,
+		b.L2,
+		b.chainConfig.ChainID,
+
+		b.l3Config.chainConfig,
+		b.l3Config.stackConfig,
+		b.l3Config.execConfig,
+		b.l3Config.nodeConfig,
+		b.l3Config.valnodeConfig,
+		b.l3Config.isSequencer,
+		b.L3Info,
+
+		b.l3InitMessage,
+		b.l3Addresses,
+	)
+
+	return func() {
+		b.L3.cleanup()
+	}
+}
+
+func (b *NodeBuilder) BuildL2OnL1(t *testing.T) func() {
+	b.L2 = buildOnParentChain(
+		t,
+		b.ctx,
+
+		b.dataDir,
+
+		b.L1Info,
+		b.L1,
+		big.NewInt(1337),
+
+		b.chainConfig,
+		b.l2StackConfig,
+		b.execConfig,
+		b.nodeConfig,
+		b.valnodeConfig,
+		b.isSequencer,
+		b.L2Info,
+
+		b.initMessage,
+		b.addresses,
+	)
 
-	b.L2.ExecNode = getExecNode(t, b.L2.ConsensusNode)
-	b.L2.cleanup = func() { b.L2.ConsensusNode.StopAndWait() }
 	return func() {
 		b.L2.cleanup()
 		if b.L1 != nil && b.L1.cleanup != nil {
@@ -463,7 +623,7 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	}
 	b.L2.cleanup()
 
-	l2info, stack, chainDb, arbDb, blockchain := createL2BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, b.execConfig)
+	l2info, stack, chainDb, arbDb, blockchain := createNonL1BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, b.execConfig)
 
 	execConfigFetcher := func() *gethexec.Config { return b.execConfig }
 	execNode, err := gethexec.CreateExecutionNode(b.ctx, stack, chainDb, blockchain, nil, execConfigFetcher)
@@ -488,13 +648,25 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	b.L2Info = l2info
 }
 
-func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
-	if b.L2 == nil {
-		t.Fatal("builder did not previously build a L2 Node")
-	}
-	if b.withL1 && b.L1 == nil {
-		t.Fatal("builder did not previously build a L1 Node")
-	}
+func build2ndNode(
+	t *testing.T,
+	ctx context.Context,
+
+	firstNodeStackConfig *node.Config,
+	firsNodeExecConfig *gethexec.Config,
+	firstNodeNodeConfig *arbnode.Config,
+	firstNodeInfo info,
+	firstNodeTestClient *TestClient,
+	valnodeConfig *valnode.Config,
+
+	parentChainTestClient *TestClient,
+	parentChainInfo info,
+
+	params *SecondNodeParams,
+
+	addresses *chaininfo.RollupAddresses,
+	initMessage *arbostypes.ParsedInitMessage,
+) (*TestClient, func()) {
 	if params.nodeConfig == nil {
 		params.nodeConfig = arbnode.ConfigDefaultL1NonSequencerTest()
 	}
@@ -502,18 +674,18 @@ func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*Tes
 		params.nodeConfig.DataAvailability = *params.dasConfig
 	}
 	if params.stackConfig == nil {
-		params.stackConfig = b.l2StackConfig
+		params.stackConfig = firstNodeStackConfig
 		// should use different dataDir from the previously used ones
 		params.stackConfig.DataDir = t.TempDir()
 	}
 	if params.initData == nil {
-		params.initData = &b.L2Info.ArbInitData
+		params.initData = &firstNodeInfo.ArbInitData
 	}
 	if params.execConfig == nil {
-		params.execConfig = b.execConfig
+		params.execConfig = firsNodeExecConfig
 	}
 	if params.addresses == nil {
-		params.addresses = b.addresses
+		params.addresses = addresses
 	}
 	if params.execConfig.RPC.MaxRecreateStateDepth == arbitrum.UninitializedMaxRecreateStateDepth {
 		if params.execConfig.Caching.Archive {
@@ -522,16 +694,69 @@ func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*Tes
 			params.execConfig.RPC.MaxRecreateStateDepth = arbitrum.DefaultNonArchiveNodeMaxRecreateStateDepth
 		}
 	}
-	if b.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.RedisUrl == "" {
+	if firstNodeNodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.RedisUrl == "" {
 		t.Fatal("The batch poster must use Redis when enabled for multiple nodes")
 	}
 
-	l2 := NewTestClient(b.ctx)
-	l2.Client, l2.ConsensusNode =
-		Create2ndNodeWithConfig(t, b.ctx, b.L2.ConsensusNode, b.L1.Stack, b.L1Info, params.initData, params.nodeConfig, params.execConfig, params.stackConfig, b.valnodeConfig, params.addresses, b.initMessage)
-	l2.ExecNode = getExecNode(t, l2.ConsensusNode)
-	l2.cleanup = func() { l2.ConsensusNode.StopAndWait() }
-	return l2, func() { l2.cleanup() }
+	testClient := NewTestClient(ctx)
+	testClient.Client, testClient.ConsensusNode =
+		Create2ndNodeWithConfig(t, ctx, firstNodeTestClient.ConsensusNode, parentChainTestClient.Stack, parentChainInfo, params.initData, params.nodeConfig, params.execConfig, params.stackConfig, valnodeConfig, params.addresses, initMessage)
+	testClient.ExecNode = getExecNode(t, testClient.ConsensusNode)
+	testClient.cleanup = func() { testClient.ConsensusNode.StopAndWait() }
+	return testClient, func() { testClient.cleanup() }
+}
+
+func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
+	if b.L2 == nil {
+		t.Fatal("builder did not previously built an L2 Node")
+	}
+	if b.withL1 && b.L1 == nil {
+		t.Fatal("builder did not previously built an L1 Node")
+	}
+	return build2ndNode(
+		t,
+		b.ctx,
+
+		b.l2StackConfig,
+		b.execConfig,
+		b.nodeConfig,
+		b.L2Info,
+		b.L2,
+		b.valnodeConfig,
+
+		b.L1,
+		b.L1Info,
+
+		params,
+
+		b.addresses,
+		b.initMessage,
+	)
+}
+
+func (b *NodeBuilder) Build2ndNodeOnL3(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
+	if b.L3 == nil {
+		t.Fatal("builder did not previously built an L3 Node")
+	}
+	return build2ndNode(
+		t,
+		b.ctx,
+
+		b.l3Config.stackConfig,
+		b.l3Config.execConfig,
+		b.l3Config.nodeConfig,
+		b.L3Info,
+		b.L3,
+		b.l3Config.valnodeConfig,
+
+		b.L2,
+		b.L2Info,
+
+		params,
+
+		b.l3Addresses,
+		b.l3InitMessage,
+	)
 }
 
 func (b *NodeBuilder) BridgeBalance(t *testing.T, account string, amount *big.Int) (*types.Transaction, *types.Receipt) {
@@ -616,7 +841,7 @@ func BridgeBalance(
 				break
 			}
 			TransferBalance(t, "Faucet", "User", big.NewInt(1), l1info, l1client, ctx)
-			if i > 20 {
+			if i > 200 {
 				Fatal(t, "bridging failed")
 			}
 			<-time.After(time.Millisecond * 100)
@@ -987,8 +1212,8 @@ func createTestL1BlockChain(t *testing.T, l1info info) (info, *ethclient.Client,
 	return l1info, l1Client, l1backend, stack
 }
 
-func getInitMessage(ctx context.Context, t *testing.T, l1client *ethclient.Client, addresses *chaininfo.RollupAddresses) *arbostypes.ParsedInitMessage {
-	bridge, err := arbnode.NewDelayedBridge(l1client, addresses.Bridge, addresses.DeployedAt)
+func getInitMessage(ctx context.Context, t *testing.T, parentChainClient *ethclient.Client, addresses *chaininfo.RollupAddresses) *arbostypes.ParsedInitMessage {
+	bridge, err := arbnode.NewDelayedBridge(parentChainClient, addresses.Bridge, addresses.DeployedAt)
 	Require(t, err)
 	deployedAtBig := arbmath.UintToBig(addresses.DeployedAt)
 	messages, err := bridge.LookupMessagesInRange(ctx, deployedAtBig, deployedAtBig, nil)
@@ -1002,64 +1227,72 @@ func getInitMessage(ctx context.Context, t *testing.T, l1client *ethclient.Clien
 	return initMessage
 }
 
-func DeployOnTestL1(
-	t *testing.T, ctx context.Context, l1info info, l1client *ethclient.Client, chainConfig *params.ChainConfig, wasmModuleRoot common.Hash, prodConfirmPeriodBlocks bool,
+func deployOnParentChain(
+	t *testing.T,
+	ctx context.Context,
+	parentChainInfo info,
+	parentChainClient *ethclient.Client,
+	parentChainReaderConfig *headerreader.Config,
+	chainConfig *params.ChainConfig,
+	wasmModuleRoot common.Hash,
+	prodConfirmPeriodBlocks bool,
+	chainSupportsBlobs bool,
 ) (*chaininfo.RollupAddresses, *arbostypes.ParsedInitMessage) {
-	l1info.GenerateAccount("RollupOwner")
-	l1info.GenerateAccount("Sequencer")
-	l1info.GenerateAccount("Validator")
-	l1info.GenerateAccount("User")
-
-	SendWaitTestTransactions(t, ctx, l1client, []*types.Transaction{
-		l1info.PrepareTx("Faucet", "RollupOwner", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "Sequencer", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "Validator", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "User", 30000, big.NewInt(9223372036854775807), nil)})
-
-	l1TransactionOpts := l1info.GetDefaultTransactOpts("RollupOwner", ctx)
+	parentChainInfo.GenerateAccount("RollupOwner")
+	parentChainInfo.GenerateAccount("Sequencer")
+	parentChainInfo.GenerateAccount("Validator")
+	parentChainInfo.GenerateAccount("User")
+
+	SendWaitTestTransactions(t, ctx, parentChainClient, []*types.Transaction{
+		parentChainInfo.PrepareTx("Faucet", "RollupOwner", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "Sequencer", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "Validator", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "User", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil)})
+
+	parentChainTransactionOpts := parentChainInfo.GetDefaultTransactOpts("RollupOwner", ctx)
 	serializedChainConfig, err := json.Marshal(chainConfig)
 	Require(t, err)
 
-	arbSys, _ := precompilesgen.NewArbSys(types.ArbSysAddress, l1client)
-	l1Reader, err := headerreader.New(ctx, l1client, func() *headerreader.Config { return &headerreader.TestConfig }, arbSys)
+	arbSys, _ := precompilesgen.NewArbSys(types.ArbSysAddress, parentChainClient)
+	parentChainReader, err := headerreader.New(ctx, parentChainClient, func() *headerreader.Config { return parentChainReaderConfig }, arbSys)
 	Require(t, err)
-	l1Reader.Start(ctx)
-	defer l1Reader.StopAndWait()
+	parentChainReader.Start(ctx)
+	defer parentChainReader.StopAndWait()
 
 	nativeToken := common.Address{}
 	maxDataSize := big.NewInt(117964)
-	addresses, err := deploy.DeployOnL1(
+	addresses, err := deploy.DeployOnParentChain(
 		ctx,
-		l1Reader,
-		&l1TransactionOpts,
-		[]common.Address{l1info.GetAddress("Sequencer")},
-		l1info.GetAddress("RollupOwner"),
+		parentChainReader,
+		&parentChainTransactionOpts,
+		[]common.Address{parentChainInfo.GetAddress("Sequencer")},
+		parentChainInfo.GetAddress("RollupOwner"),
 		0,
-		arbnode.GenerateRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, l1info.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}),
+		arbnode.GenerateRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, parentChainInfo.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}),
 		nativeToken,
 		maxDataSize,
-		false,
+		chainSupportsBlobs,
 	)
 	Require(t, err)
-	l1info.SetContract("Bridge", addresses.Bridge)
-	l1info.SetContract("SequencerInbox", addresses.SequencerInbox)
-	l1info.SetContract("Inbox", addresses.Inbox)
-	l1info.SetContract("UpgradeExecutor", addresses.UpgradeExecutor)
-	initMessage := getInitMessage(ctx, t, l1client, addresses)
+	parentChainInfo.SetContract("Bridge", addresses.Bridge)
+	parentChainInfo.SetContract("SequencerInbox", addresses.SequencerInbox)
+	parentChainInfo.SetContract("Inbox", addresses.Inbox)
+	parentChainInfo.SetContract("UpgradeExecutor", addresses.UpgradeExecutor)
+	initMessage := getInitMessage(ctx, t, parentChainClient, addresses)
 	return addresses, initMessage
 }
 
 func createL2BlockChain(
 	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, execConfig *gethexec.Config,
 ) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
-	return createL2BlockChainWithStackConfig(t, l2info, dataDir, chainConfig, nil, nil, execConfig)
+	return createNonL1BlockChainWithStackConfig(t, l2info, dataDir, chainConfig, nil, nil, execConfig)
 }
 
-func createL2BlockChainWithStackConfig(
-	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, execConfig *gethexec.Config,
+func createNonL1BlockChainWithStackConfig(
+	t *testing.T, info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, execConfig *gethexec.Config,
 ) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
-	if l2info == nil {
-		l2info = NewArbTestInfo(t, chainConfig.ChainID)
+	if info == nil {
+		info = NewArbTestInfo(t, chainConfig.ChainID)
 	}
 	if stackConfig == nil {
 		stackConfig = testhelpers.CreateStackConfigForTest(dataDir)
@@ -1079,7 +1312,7 @@ func createL2BlockChainWithStackConfig(
 	arbDb, err := stack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
 	Require(t, err)
 
-	initReader := statetransfer.NewMemoryInitDataReader(&l2info.ArbInitData)
+	initReader := statetransfer.NewMemoryInitDataReader(&info.ArbInitData)
 	if initMessage == nil {
 		serializedChainConfig, err := json.Marshal(chainConfig)
 		Require(t, err)
@@ -1094,7 +1327,7 @@ func createL2BlockChainWithStackConfig(
 	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest(t).TxLookupLimit, 0)
 	Require(t, err)
 
-	return l2info, stack, chainDb, arbDb, blockchain
+	return info, stack, chainDb, arbDb, blockchain
 }
 
 func ClientForStack(t *testing.T, backend *node.Node) *ethclient.Client {
@@ -1137,9 +1370,9 @@ func Create2ndNodeWithConfig(
 	t *testing.T,
 	ctx context.Context,
 	first *arbnode.Node,
-	l1stack *node.Node,
-	l1info *BlockchainTestInfo,
-	l2InitData *statetransfer.ArbosInitializationInfo,
+	parentChainStack *node.Node,
+	parentChainInfo *BlockchainTestInfo,
+	chainInitData *statetransfer.ArbosInitializationInfo,
 	nodeConfig *arbnode.Config,
 	execConfig *gethexec.Config,
 	stackConfig *node.Config,
@@ -1154,34 +1387,34 @@ func Create2ndNodeWithConfig(
 		execConfig = ExecConfigDefaultNonSequencerTest(t)
 	}
 	feedErrChan := make(chan error, 10)
-	l1rpcClient := l1stack.Attach()
-	l1client := ethclient.NewClient(l1rpcClient)
+	parentChainRpcClient := parentChainStack.Attach()
+	parentChainClient := ethclient.NewClient(parentChainRpcClient)
 
 	if stackConfig == nil {
 		stackConfig = testhelpers.CreateStackConfigForTest(t.TempDir())
 	}
-	l2stack, err := node.New(stackConfig)
+	chainStack, err := node.New(stackConfig)
 	Require(t, err)
 
-	l2chainData, err := l2stack.OpenDatabaseWithExtraOptions("l2chaindata", 0, 0, "l2chaindata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata"))
+	chainData, err := chainStack.OpenDatabaseWithExtraOptions("l2chaindata", 0, 0, "l2chaindata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata"))
 	Require(t, err)
-	wasmData, err := l2stack.OpenDatabaseWithExtraOptions("wasm", 0, 0, "wasm/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"))
+	wasmData, err := chainStack.OpenDatabaseWithExtraOptions("wasm", 0, 0, "wasm/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"))
 	Require(t, err)
-	l2chainDb := rawdb.WrapDatabaseWithWasm(l2chainData, wasmData, 0, execConfig.StylusTarget.WasmTargets())
+	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmData, 0, execConfig.StylusTarget.WasmTargets())
 
-	l2arbDb, err := l2stack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
+	arbDb, err := chainStack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
 	Require(t, err)
-	initReader := statetransfer.NewMemoryInitDataReader(l2InitData)
+	initReader := statetransfer.NewMemoryInitDataReader(chainInitData)
 
-	dataSigner := signature.DataSignerFromPrivateKey(l1info.GetInfoWithPrivKey("Sequencer").PrivateKey)
-	sequencerTxOpts := l1info.GetDefaultTransactOpts("Sequencer", ctx)
-	validatorTxOpts := l1info.GetDefaultTransactOpts("Validator", ctx)
+	dataSigner := signature.DataSignerFromPrivateKey(parentChainInfo.GetInfoWithPrivKey("Sequencer").PrivateKey)
+	sequencerTxOpts := parentChainInfo.GetDefaultTransactOpts("Sequencer", ctx)
+	validatorTxOpts := parentChainInfo.GetDefaultTransactOpts("Validator", ctx)
 	firstExec := getExecNode(t, first)
 
 	chainConfig := firstExec.ArbInterface.BlockChain().Config()
 
-	coreCacheConfig := gethexec.DefaultCacheConfigFor(l2stack, &execConfig.Caching)
-	l2blockchain, err := gethexec.WriteOrTestBlockChain(l2chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest(t).TxLookupLimit, 0)
+	coreCacheConfig := gethexec.DefaultCacheConfigFor(chainStack, &execConfig.Caching)
+	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest(t).TxLookupLimit, 0)
 	Require(t, err)
 
 	AddValNodeIfNeeded(t, ctx, nodeConfig, true, "", valnodeConfig.Wasm.RootPath)
@@ -1189,19 +1422,19 @@ func Create2ndNodeWithConfig(
 	Require(t, execConfig.Validate())
 	Require(t, nodeConfig.Validate())
 	configFetcher := func() *gethexec.Config { return execConfig }
-	currentExec, err := gethexec.CreateExecutionNode(ctx, l2stack, l2chainDb, l2blockchain, l1client, configFetcher)
+	currentExec, err := gethexec.CreateExecutionNode(ctx, chainStack, chainDb, blockchain, parentChainClient, configFetcher)
 	Require(t, err)
 
-	currentNode, err := arbnode.CreateNode(ctx, l2stack, currentExec, l2arbDb, NewFetcherFromConfig(nodeConfig), l2blockchain.Config(), l1client, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil)
+	currentNode, err := arbnode.CreateNode(ctx, chainStack, currentExec, arbDb, NewFetcherFromConfig(nodeConfig), blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil)
 	Require(t, err)
 
 	err = currentNode.Start(ctx)
 	Require(t, err)
-	l2client := ClientForStack(t, l2stack)
+	chainClient := ClientForStack(t, chainStack)
 
 	StartWatchChanErr(t, ctx, feedErrChan, currentNode)
 
-	return l2client, currentNode
+	return chainClient, currentNode
 }
 
 func GetBalance(t *testing.T, ctx context.Context, client *ethclient.Client, account common.Address) *big.Int {
@@ -1461,6 +1694,34 @@ func logParser[T any](t *testing.T, source string, name string) func(*types.Log)
 	}
 }
 
+// recordBlock writes a json file with all of the data needed to validate a block.
+//
+// This can be used as an input to the arbitrator prover to validate a block.
+func recordBlock(t *testing.T, block uint64, builder *NodeBuilder) {
+	t.Helper()
+	ctx := builder.ctx
+	inboxPos := arbutil.MessageIndex(block)
+	for {
+		time.Sleep(250 * time.Millisecond)
+		batches, err := builder.L2.ConsensusNode.InboxTracker.GetBatchCount()
+		Require(t, err)
+		haveMessages, err := builder.L2.ConsensusNode.InboxTracker.GetBatchMessageCount(batches - 1)
+		Require(t, err)
+		if haveMessages >= inboxPos {
+			break
+		}
+	}
+	validationInputsWriter, err := inputs.NewWriter(inputs.WithSlug(t.Name()))
+	Require(t, err)
+	inputJson, err := builder.L2.ConsensusNode.StatelessBlockValidator.ValidationInputsAt(ctx, inboxPos, rawdb.TargetWavm)
+	if err != nil {
+		Fatal(t, "failed to get validation inputs", block, err)
+	}
+	if err := validationInputsWriter.Write(&inputJson); err != nil {
+		Fatal(t, "failed to write validation inputs", block, err)
+	}
+}
+
 func populateMachineDir(t *testing.T, cr *github.ConsensusRelease) string {
 	baseDir := t.TempDir()
 	machineDir := baseDir + "/machines"
diff --git a/system_tests/eth_sync_test.go b/system_tests/eth_sync_test.go
index 1f07f7c45f..ce9994fb1e 100644
--- a/system_tests/eth_sync_test.go
+++ b/system_tests/eth_sync_test.go
@@ -71,7 +71,7 @@ func TestEthSyncing(t *testing.T) {
 	if progress == nil {
 		Fatal(t, "eth_syncing returned nil but shouldn't have")
 	}
-	for testClientB.ConsensusNode.TxStreamer.ExecuteNextMsg(ctx, testClientB.ExecNode) {
+	for testClientB.ConsensusNode.TxStreamer.ExecuteNextMsg(ctx) {
 	}
 	progress, err = testClientB.Client.SyncProgress(ctx)
 	Require(t, err)
diff --git a/system_tests/l3_test.go b/system_tests/l3_test.go
new file mode 100644
index 0000000000..97eabcee78
--- /dev/null
+++ b/system_tests/l3_test.go
@@ -0,0 +1,53 @@
+package arbtest
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/offchainlabs/nitro/arbnode"
+)
+
+func TestSimpleL3(t *testing.T) {
+	t.Parallel()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	cleanupL1AndL2 := builder.Build(t)
+	defer cleanupL1AndL2()
+
+	cleanupL3FirstNode := builder.BuildL3OnL2(t)
+	defer cleanupL3FirstNode()
+	firstNodeTestClient := builder.L3
+
+	secondNodeNodeConfig := arbnode.ConfigDefaultL1NonSequencerTest()
+	secondNodeTestClient, cleanupL3SecondNode := builder.Build2ndNodeOnL3(t, &SecondNodeParams{nodeConfig: secondNodeNodeConfig})
+	defer cleanupL3SecondNode()
+
+	accountName := "User2"
+	builder.L3Info.GenerateAccount(accountName)
+	tx := builder.L3Info.PrepareTx("Owner", accountName, builder.L3Info.TransferGas, big.NewInt(1e12), nil)
+
+	err := firstNodeTestClient.Client.SendTransaction(ctx, tx)
+	Require(t, err)
+
+	// Checks that first node has the correct balance
+	_, err = firstNodeTestClient.EnsureTxSucceeded(tx)
+	Require(t, err)
+	l2balance, err := firstNodeTestClient.Client.BalanceAt(ctx, builder.L3Info.GetAddress(accountName), nil)
+	Require(t, err)
+	if l2balance.Cmp(big.NewInt(1e12)) != 0 {
+		t.Fatal("Unexpected balance:", l2balance)
+	}
+
+	// Checks that second node has the correct balance
+	_, err = WaitForTx(ctx, secondNodeTestClient.Client, tx.Hash(), time.Second*15)
+	Require(t, err)
+	l2balance, err = secondNodeTestClient.Client.BalanceAt(ctx, builder.L3Info.GetAddress(accountName), nil)
+	Require(t, err)
+	if l2balance.Cmp(big.NewInt(1e12)) != 0 {
+		t.Fatal("Unexpected balance:", l2balance)
+	}
+}
diff --git a/system_tests/program_test.go b/system_tests/program_test.go
index 83c066fdb5..cf8cd72559 100644
--- a/system_tests/program_test.go
+++ b/system_tests/program_test.go
@@ -417,10 +417,15 @@ func storageTest(t *testing.T, jit bool) {
 	key := testhelpers.RandomHash()
 	value := testhelpers.RandomHash()
 	tx := l2info.PrepareTxTo("Owner", &programAddress, l2info.TransferGas, nil, argsForStorageWrite(key, value))
-	ensure(tx, l2client.SendTransaction(ctx, tx))
+	receipt := ensure(tx, l2client.SendTransaction(ctx, tx))
+
 	assertStorageAt(t, ctx, l2client, programAddress, key, value)
 
 	validateBlocks(t, 2, jit, builder)
+
+	// Captures a block_input_<id>.json file for the block that included the
+	// storage write transaction.
+	recordBlock(t, receipt.BlockNumber.Uint64(), builder)
 }
 
 func TestProgramTransientStorage(t *testing.T) {
@@ -2007,3 +2012,128 @@ func checkWasmStoreContent(t *testing.T, wasmDb ethdb.KeyValueStore, targets []s
 		}
 	}
 }
+
+func deployWasmAndGetLruEntrySizeEstimateBytes(
+	t *testing.T,
+	builder *NodeBuilder,
+	auth bind.TransactOpts,
+	wasmName string,
+) (common.Address, uint64) {
+	ctx := builder.ctx
+	l2client := builder.L2.Client
+
+	wasm, _ := readWasmFile(t, rustFile(wasmName))
+	arbWasm, err := pgen.NewArbWasm(types.ArbWasmAddress, l2client)
+	Require(t, err, ", wasmName:", wasmName)
+
+	programAddress := deployContract(t, ctx, auth, l2client, wasm)
+	tx, err := arbWasm.ActivateProgram(&auth, programAddress)
+	Require(t, err, ", wasmName:", wasmName)
+	receipt, err := EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err, ", wasmName:", wasmName)
+
+	if len(receipt.Logs) != 1 {
+		Fatal(t, "expected 1 log while activating, got ", len(receipt.Logs), ", wasmName:", wasmName)
+	}
+	log, err := arbWasm.ParseProgramActivated(*receipt.Logs[0])
+	Require(t, err, ", wasmName:", wasmName)
+
+	statedb, err := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().State()
+	Require(t, err, ", wasmName:", wasmName)
+
+	module, err := statedb.TryGetActivatedAsm(rawdb.LocalTarget(), log.ModuleHash)
+	Require(t, err, ", wasmName:", wasmName)
+
+	lruEntrySizeEstimateBytes := programs.GetLruEntrySizeEstimateBytes(module, log.Version, true)
+	// just a sanity check
+	if lruEntrySizeEstimateBytes == 0 {
+		Fatal(t, "lruEntrySizeEstimateBytes is 0, wasmName:", wasmName)
+	}
+	return programAddress, lruEntrySizeEstimateBytes
+}
+
+func TestWasmLruCache(t *testing.T) {
+	builder, auth, cleanup := setupProgramTest(t, true)
+	ctx := builder.ctx
+	l2info := builder.L2Info
+	l2client := builder.L2.Client
+	defer cleanup()
+
+	auth.GasLimit = 32000000
+	auth.Value = oneEth
+
+	fallibleProgramAddress, fallibleLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "fallible")
+	keccakProgramAddress, keccakLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "keccak")
+	mathProgramAddress, mathLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "math")
+	t.Log(
+		"lruEntrySizeEstimateBytes, ",
+		"fallible:", fallibleLruEntrySizeEstimateBytes,
+		"keccak:", keccakLruEntrySizeEstimateBytes,
+		"math:", mathLruEntrySizeEstimateBytes,
+	)
+
+	programs.ClearWasmLruCache()
+	lruMetrics := programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 0 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 0, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != 0 {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", 0, lruMetrics.SizeBytes)
+	}
+
+	programs.SetWasmLruCacheCapacity(fallibleLruEntrySizeEstimateBytes - 1)
+	// fallible wasm program will not be cached since its size is greater than lru cache capacity
+	tx := l2info.PrepareTxTo("Owner", &fallibleProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err := EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 0 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 0, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != 0 {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", 0, lruMetrics.SizeBytes)
+	}
+
+	programs.SetWasmLruCacheCapacity(
+		fallibleLruEntrySizeEstimateBytes + keccakLruEntrySizeEstimateBytes + mathLruEntrySizeEstimateBytes - 1,
+	)
+	// fallible wasm program will be cached
+	tx = l2info.PrepareTxTo("Owner", &fallibleProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 1 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 1, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != fallibleLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", fallibleLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+
+	// keccak wasm program will be cached
+	tx = l2info.PrepareTxTo("Owner", &keccakProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 2 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 2, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != fallibleLruEntrySizeEstimateBytes+keccakLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", fallibleLruEntrySizeEstimateBytes+keccakLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+
+	// math wasm program will be cached, but fallible will be evicted since (fallible + keccak + math) > lruCacheCapacity
+	tx = l2info.PrepareTxTo("Owner", &mathProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 2 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 2, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != keccakLruEntrySizeEstimateBytes+mathLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", keccakLruEntrySizeEstimateBytes+mathLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+}
diff --git a/system_tests/stylus_trace_test.go b/system_tests/stylus_trace_test.go
index 5c4463d9f7..52039df460 100644
--- a/system_tests/stylus_trace_test.go
+++ b/system_tests/stylus_trace_test.go
@@ -6,6 +6,7 @@ package arbtest
 import (
 	"bytes"
 	"encoding/binary"
+	"math"
 	"math/big"
 	"testing"
 
@@ -478,3 +479,17 @@ func TestStylusOpcodeTraceEquivalence(t *testing.T) {
 	checkOpcode(t, wasmResult, 12, vm.RETURN, offset, returnLen)
 	checkOpcode(t, evmResult, 5078, vm.RETURN, offset, returnLen)
 }
+
+func TestStylusHugeWriteResultTrace(t *testing.T) {
+	const jit = false
+	builder, auth, cleanup := setupProgramTest(t, jit)
+	ctx := builder.ctx
+	l2client := builder.L2.Client
+	defer cleanup()
+
+	program := deployWasm(t, ctx, auth, l2client, watFile("write-result-len"))
+	const returnLen = math.MaxUint16 + 1
+	args := binary.LittleEndian.AppendUint32(nil, returnLen)
+	result := sendAndTraceTransaction(t, builder, program, nil, args)
+	checkOpcode(t, result, 3, vm.RETURN, nil, intToBe32(returnLen))
+}
diff --git a/system_tests/validation_mock_test.go b/system_tests/validation_mock_test.go
index 2739c7545e..912b48ea6a 100644
--- a/system_tests/validation_mock_test.go
+++ b/system_tests/validation_mock_test.go
@@ -96,10 +96,6 @@ func (s *mockSpawner) LatestWasmModuleRoot() containers.PromiseInterface[common.
 	return containers.NewReadyPromise[common.Hash](mockWasmModuleRoots[0], nil)
 }
 
-func (s *mockSpawner) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	return containers.NewReadyPromise[struct{}](struct{}{}, nil)
-}
-
 type mockValRun struct {
 	containers.Promise[validator.GoGlobalState]
 	root common.Hash
diff --git a/validator/client/validation_client.go b/validator/client/validation_client.go
index 3b18ad1851..934362f00a 100644
--- a/validator/client/validation_client.go
+++ b/validator/client/validation_client.go
@@ -188,19 +188,6 @@ func (c *ExecutionClient) LatestWasmModuleRoot() containers.PromiseInterface[com
 	})
 }
 
-func (c *ExecutionClient) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	jsonInput := server_api.ValidationInputToJson(input)
-	if err := jsonInput.WriteToFile(); err != nil {
-		return stopwaiter.LaunchPromiseThread[struct{}](c, func(ctx context.Context) (struct{}, error) {
-			return struct{}{}, err
-		})
-	}
-	return stopwaiter.LaunchPromiseThread[struct{}](c, func(ctx context.Context) (struct{}, error) {
-		err := c.client.CallContext(ctx, nil, server_api.Namespace+"_writeToFile", jsonInput, expOut, moduleRoot)
-		return struct{}{}, err
-	})
-}
-
 func (r *ExecutionClientRun) SendKeepAlive(ctx context.Context) time.Duration {
 	err := r.client.client.CallContext(ctx, nil, server_api.Namespace+"_execKeepAlive", r.id)
 	if err != nil {
diff --git a/validator/inputs/writer.go b/validator/inputs/writer.go
new file mode 100644
index 0000000000..a45e584f52
--- /dev/null
+++ b/validator/inputs/writer.go
@@ -0,0 +1,141 @@
+package inputs
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/offchainlabs/nitro/validator/server_api"
+)
+
+// Writer is a configurable writer of InputJSON files.
+//
+// The default Writer will write to a path like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+//
+// The path can be nested under a slug directory so callers can provide a
+// recognizable name to differentiate various contexts in which the InputJSON
+// is being written. If the Writer is configured by calling SetSlug, then the
+// path will be like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+//
+// The inclusion of a timestamp directory is on by default to avoid conflicts which
+// would result in files being overwritten. However, the Writer can be configured
+// to not use a timestamp directory.  If the Writer is configured by calling
+// SetUseTimestampDir(false), then the path will be like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<slug>/block_inputs_<id>.json
+//
+// Finally, to give complete control to the clients, the base directory can be
+// set directly with SetBaseDir. In which case, the path will be like:
+//
+//	<baseDir>/block_inputs_<id>.json
+//	  or
+//	<baseDir>/<slug>/block_inputs_<id>.json
+//	  or
+//	<baseDir>/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+type Writer struct {
+	clock           Clock
+	baseDir         string
+	slug            string
+	useTimestampDir bool
+}
+
+// WriterOption is a function that configures a Writer.
+type WriterOption func(*Writer)
+
+// Clock is an interface for getting the current time.
+type Clock interface {
+	Now() time.Time
+}
+
+type realClock struct{}
+
+func (realClock) Now() time.Time {
+	return time.Now()
+}
+
+// NewWriter creates a new Writer with default settings.
+func NewWriter(options ...WriterOption) (*Writer, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return nil, err
+	}
+	baseDir := filepath.Join(homeDir, ".arbitrum", "validation-inputs")
+	w := &Writer{
+		clock:           realClock{},
+		baseDir:         baseDir,
+		slug:            "",
+		useTimestampDir: true,
+	}
+	for _, o := range options {
+		o(w)
+	}
+	return w, nil
+}
+
+// withTestClock configures the Writer to use the given clock.
+//
+// This is only intended for testing.
+func withTestClock(clock Clock) WriterOption {
+	return func(w *Writer) {
+		w.clock = clock
+	}
+}
+
+// WithSlug configures the Writer to use the given slug as a directory name.
+func WithSlug(slug string) WriterOption {
+	return func(w *Writer) {
+		w.slug = slug
+	}
+}
+
+// WithoutSlug clears the slug configuration.
+//
+// This is equivalent to the WithSlug("") option but is more readable.
+func WithoutSlug() WriterOption {
+	return WithSlug("")
+}
+
+// WithBaseDir configures the Writer to use the given base directory.
+func WithBaseDir(baseDir string) WriterOption {
+	return func(w *Writer) {
+		w.baseDir = baseDir
+	}
+}
+
+// WithTimestampDirEnabled controls the addition of a timestamp directory.
+func WithTimestampDirEnabled(useTimestampDir bool) WriterOption {
+	return func(w *Writer) {
+		w.useTimestampDir = useTimestampDir
+	}
+}
+
+// Write writes the given InputJSON to a file in JSON format.
+func (w *Writer) Write(json *server_api.InputJSON) error {
+	dir := w.baseDir
+	if w.slug != "" {
+		dir = filepath.Join(dir, w.slug)
+	}
+	if w.useTimestampDir {
+		t := w.clock.Now()
+		tStr := t.Format("20060102_150405")
+		dir = filepath.Join(dir, tStr)
+	}
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return err
+	}
+	contents, err := json.Marshal()
+	if err != nil {
+		return err
+	}
+	if err = os.WriteFile(
+		filepath.Join(dir, fmt.Sprintf("block_inputs_%d.json", json.Id)),
+		contents, 0600); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/validator/inputs/writer_test.go b/validator/inputs/writer_test.go
new file mode 100644
index 0000000000..59cb63dae7
--- /dev/null
+++ b/validator/inputs/writer_test.go
@@ -0,0 +1,92 @@
+package inputs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/offchainlabs/nitro/validator/server_api"
+)
+
+func TestDefaultBaseDir(t *testing.T) {
+	// Simply testing that the default baseDir is set relative to the user's home directory.
+	// This way, the other tests can all override the baseDir to a temporary directory.
+	w, err := NewWriter()
+	if err != nil {
+		t.Fatal(err)
+	}
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.baseDir != homeDir+"/.arbitrum/validation-inputs" {
+		t.Errorf("unexpected baseDir: %v", w.baseDir)
+	}
+}
+
+type fakeClock struct {
+	now time.Time
+}
+
+func (c fakeClock) Now() time.Time {
+	return c.now
+}
+
+func TestWriting(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/20210102_030405/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestWritingWithSlug(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+		WithSlug("foo"),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/foo/20210102_030405/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestWritingWithoutTimestampDir(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+		WithTimestampDirEnabled(false),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
diff --git a/validator/interface.go b/validator/interface.go
index af08629137..9fb831ca0d 100644
--- a/validator/interface.go
+++ b/validator/interface.go
@@ -27,7 +27,6 @@ type ExecutionSpawner interface {
 	ValidationSpawner
 	CreateExecutionRun(wasmModuleRoot common.Hash, input *ValidationInput) containers.PromiseInterface[ExecutionRun]
 	LatestWasmModuleRoot() containers.PromiseInterface[common.Hash]
-	WriteToFile(input *ValidationInput, expOut GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}]
 }
 
 type ExecutionRun interface {
diff --git a/validator/server_api/json.go b/validator/server_api/json.go
index 6fe936e17d..8dfbc8446a 100644
--- a/validator/server_api/json.go
+++ b/validator/server_api/json.go
@@ -8,7 +8,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -68,15 +67,9 @@ type InputJSON struct {
 	DebugChain    bool
 }
 
-func (i *InputJSON) WriteToFile() error {
-	contents, err := json.MarshalIndent(i, "", "    ")
-	if err != nil {
-		return err
-	}
-	if err = os.WriteFile(fmt.Sprintf("block_inputs_%d.json", i.Id), contents, 0600); err != nil {
-		return err
-	}
-	return nil
+// Marshal returns the JSON encoding of the InputJSON.
+func (i *InputJSON) Marshal() ([]byte, error) {
+	return json.MarshalIndent(i, "", "    ")
 }
 
 type BatchInfoJson struct {
diff --git a/validator/server_arb/machine.go b/validator/server_arb/machine.go
index adca9695e2..1e73e6b212 100644
--- a/validator/server_arb/machine.go
+++ b/validator/server_arb/machine.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 
 ResolvedPreimage preimageResolverC(size_t context, uint8_t preimageType, const uint8_t* hash);
diff --git a/validator/server_arb/nitro_machine.go b/validator/server_arb/nitro_machine.go
index 2b2cb230b6..926b1e8930 100644
--- a/validator/server_arb/nitro_machine.go
+++ b/validator/server_arb/nitro_machine.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 #include <stdlib.h>
 */
diff --git a/validator/server_arb/preimage_resolver.go b/validator/server_arb/preimage_resolver.go
index cd4ea40e28..f01d79f4dd 100644
--- a/validator/server_arb/preimage_resolver.go
+++ b/validator/server_arb/preimage_resolver.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 
 extern ResolvedPreimage preimageResolver(size_t context, uint8_t preimageType, const uint8_t* hash);
diff --git a/validator/server_arb/prover_interface.go b/validator/server_arb/prover_interface.go
index bdd81ed588..3010d2138d 100644
--- a/validator/server_arb/prover_interface.go
+++ b/validator/server_arb/prover_interface.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../target/include/
+#cgo CFLAGS: -g -I../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 #include <stdlib.h>
diff --git a/validator/server_arb/validator_spawner.go b/validator/server_arb/validator_spawner.go
index 6f0d0cee1d..07971e2ba5 100644
--- a/validator/server_arb/validator_spawner.go
+++ b/validator/server_arb/validator_spawner.go
@@ -2,11 +2,8 @@ package server_arb
 
 import (
 	"context"
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"runtime"
 	"sync/atomic"
 	"time"
@@ -98,7 +95,7 @@ func (s *ArbitratorSpawner) Name() string {
 	return "arbitrator"
 }
 
-func (v *ArbitratorSpawner) loadEntryToMachine(ctx context.Context, entry *validator.ValidationInput, mach *ArbitratorMachine) error {
+func (v *ArbitratorSpawner) loadEntryToMachine(_ context.Context, entry *validator.ValidationInput, mach *ArbitratorMachine) error {
 	resolver := func(ty arbutil.PreimageType, hash common.Hash) ([]byte, error) {
 		// Check if it's a known preimage
 		if preimage, ok := entry.Preimages[ty][hash]; ok {
@@ -192,6 +189,7 @@ func (v *ArbitratorSpawner) execute(
 }
 
 func (v *ArbitratorSpawner) Launch(entry *validator.ValidationInput, moduleRoot common.Hash) validator.ValidationRun {
+	println("LAUCHING ARBITRATOR VALIDATION")
 	v.count.Add(1)
 	promise := stopwaiter.LaunchPromiseThread[validator.GoGlobalState](v, func(ctx context.Context) (validator.GoGlobalState, error) {
 		defer v.count.Add(-1)
@@ -208,139 +206,6 @@ func (v *ArbitratorSpawner) Room() int {
 	return avail
 }
 
-var launchTime = time.Now().Format("2006_01_02__15_04")
-
-//nolint:gosec
-func (v *ArbitratorSpawner) writeToFile(ctx context.Context, input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) error {
-	outDirPath := filepath.Join(v.locator.RootPath(), v.config().OutputPath, launchTime, fmt.Sprintf("block_%d", input.Id))
-	err := os.MkdirAll(outDirPath, 0755)
-	if err != nil {
-		return err
-	}
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	rootPathAssign := ""
-	if executable, err := os.Executable(); err == nil {
-		rootPathAssign = "ROOTPATH=\"" + filepath.Dir(executable) + "\"\n"
-	}
-	cmdFile, err := os.OpenFile(filepath.Join(outDirPath, "run-prover.sh"), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
-	if err != nil {
-		return err
-	}
-	defer cmdFile.Close()
-	_, err = cmdFile.WriteString("#!/bin/bash\n" +
-		fmt.Sprintf("# expected output: batch %d, postion %d, hash %s\n", expOut.Batch, expOut.PosInBatch, expOut.BlockHash) +
-		"MACHPATH=\"" + v.locator.GetMachinePath(moduleRoot) + "\"\n" +
-		rootPathAssign +
-		"if (( $# > 1 )); then\n" +
-		"	if [[ $1 == \"-m\" ]]; then\n" +
-		"		MACHPATH=$2\n" +
-		"		shift\n" +
-		"		shift\n" +
-		"	fi\n" +
-		"fi\n" +
-		"${ROOTPATH}/bin/prover ${MACHPATH}/replay.wasm")
-	if err != nil {
-		return err
-	}
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	libraries := []string{"soft-float.wasm", "wasi_stub.wasm", "go_stub.wasm", "host_io.wasm", "brotli.wasm"}
-	for _, module := range libraries {
-		_, err = cmdFile.WriteString(" -l " + "${MACHPATH}/" + module)
-		if err != nil {
-			return err
-		}
-	}
-	_, err = cmdFile.WriteString(fmt.Sprintf(" --inbox-position %d --position-within-message %d --last-block-hash %s", input.StartState.Batch, input.StartState.PosInBatch, input.StartState.BlockHash))
-	if err != nil {
-		return err
-	}
-
-	for _, msg := range input.BatchInfo {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		sequencerFileName := fmt.Sprintf("sequencer_%d.bin", msg.Number)
-		err = os.WriteFile(filepath.Join(outDirPath, sequencerFileName), msg.Data, 0644)
-		if err != nil {
-			return err
-		}
-		_, err = cmdFile.WriteString(" --inbox " + sequencerFileName)
-		if err != nil {
-			return err
-		}
-	}
-
-	preimageFile, err := os.Create(filepath.Join(outDirPath, "preimages.bin"))
-	if err != nil {
-		return err
-	}
-	defer preimageFile.Close()
-	for ty, preimages := range input.Preimages {
-		_, err = preimageFile.Write([]byte{byte(ty)})
-		if err != nil {
-			return err
-		}
-		for _, data := range preimages {
-			if ctx.Err() != nil {
-				return ctx.Err()
-			}
-			lenbytes := make([]byte, 8)
-			binary.LittleEndian.PutUint64(lenbytes, uint64(len(data)))
-			_, err := preimageFile.Write(lenbytes)
-			if err != nil {
-				return err
-			}
-			_, err = preimageFile.Write(data)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	_, err = cmdFile.WriteString(" --preimages preimages.bin")
-	if err != nil {
-		return err
-	}
-
-	if input.HasDelayedMsg {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		_, err = cmdFile.WriteString(fmt.Sprintf(" --delayed-inbox-position %d", input.DelayedMsgNr))
-		if err != nil {
-			return err
-		}
-		filename := fmt.Sprintf("delayed_%d.bin", input.DelayedMsgNr)
-		err = os.WriteFile(filepath.Join(outDirPath, filename), input.DelayedMsg, 0644)
-		if err != nil {
-			return err
-		}
-		_, err = cmdFile.WriteString(fmt.Sprintf(" --delayed-inbox %s", filename))
-		if err != nil {
-			return err
-		}
-	}
-
-	_, err = cmdFile.WriteString(" \"$@\"\n")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (v *ArbitratorSpawner) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	return stopwaiter.LaunchPromiseThread[struct{}](v, func(ctx context.Context) (struct{}, error) {
-		err := v.writeToFile(ctx, input, expOut, moduleRoot)
-		return struct{}{}, err
-	})
-}
-
 func (v *ArbitratorSpawner) CreateExecutionRun(wasmModuleRoot common.Hash, input *validator.ValidationInput) containers.PromiseInterface[validator.ExecutionRun] {
 	getMachine := func(ctx context.Context) (MachineInterface, error) {
 		initialFrozenMachine, err := v.machineLoader.GetZeroStepMachine(ctx, wasmModuleRoot)
diff --git a/validator/server_jit/jit_machine.go b/validator/server_jit/jit_machine.go
index 06c451bda1..0748101277 100644
--- a/validator/server_jit/jit_machine.go
+++ b/validator/server_jit/jit_machine.go
@@ -30,9 +30,10 @@ type JitMachine struct {
 	process              *exec.Cmd
 	stdin                io.WriteCloser
 	wasmMemoryUsageLimit int
+	maxExecutionTime     time.Duration
 }
 
-func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmMemoryUsageLimit int, moduleRoot common.Hash, fatalErrChan chan error) (*JitMachine, error) {
+func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmMemoryUsageLimit int, maxExecutionTime time.Duration, _ common.Hash, fatalErrChan chan error) (*JitMachine, error) {
 	invocation := []string{"--binary", binaryPath, "--forks"}
 	if cranelift {
 		invocation = append(invocation, "--cranelift")
@@ -55,6 +56,7 @@ func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmM
 		process:              process,
 		stdin:                stdin,
 		wasmMemoryUsageLimit: wasmMemoryUsageLimit,
+		maxExecutionTime:     maxExecutionTime,
 	}
 	return machine, nil
 }
@@ -73,7 +75,7 @@ func (machine *JitMachine) prove(
 	defer cancel() // ensure our cleanup functions run when we're done
 	state := validator.GoGlobalState{}
 
-	timeout := time.Now().Add(60 * time.Second)
+	timeout := time.Now().Add(machine.maxExecutionTime)
 	tcp, err := net.ListenTCP("tcp4", &net.TCPAddr{
 		IP: []byte{127, 0, 0, 1},
 	})
diff --git a/validator/server_jit/machine_loader.go b/validator/server_jit/machine_loader.go
index cfa475370c..3d8b01367f 100644
--- a/validator/server_jit/machine_loader.go
+++ b/validator/server_jit/machine_loader.go
@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/offchainlabs/nitro/validator/server_common"
@@ -52,14 +53,14 @@ type JitMachineLoader struct {
 	stopped bool
 }
 
-func NewJitMachineLoader(config *JitMachineConfig, locator *server_common.MachineLocator, fatalErrChan chan error) (*JitMachineLoader, error) {
+func NewJitMachineLoader(config *JitMachineConfig, locator *server_common.MachineLocator, maxExecutionTime time.Duration, fatalErrChan chan error) (*JitMachineLoader, error) {
 	jitPath, err := getJitPath()
 	if err != nil {
 		return nil, err
 	}
 	createMachineThreadFunc := func(ctx context.Context, moduleRoot common.Hash) (*JitMachine, error) {
 		binPath := filepath.Join(locator.GetMachinePath(moduleRoot), config.ProverBinPath)
-		return createJitMachine(jitPath, binPath, config.JitCranelift, config.WasmMemoryUsageLimit, moduleRoot, fatalErrChan)
+		return createJitMachine(jitPath, binPath, config.JitCranelift, config.WasmMemoryUsageLimit, maxExecutionTime, moduleRoot, fatalErrChan)
 	}
 	return &JitMachineLoader{
 		MachineLoader: *server_common.NewMachineLoader[JitMachine](locator, createMachineThreadFunc),
diff --git a/validator/server_jit/spawner.go b/validator/server_jit/spawner.go
index d77317d218..f30b6e181a 100644
--- a/validator/server_jit/spawner.go
+++ b/validator/server_jit/spawner.go
@@ -3,10 +3,10 @@ package server_jit
 import (
 	"context"
 	"fmt"
+	flag "github.com/spf13/pflag"
 	"runtime"
 	"sync/atomic"
-
-	flag "github.com/spf13/pflag"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -18,8 +18,9 @@ import (
 )
 
 type JitSpawnerConfig struct {
-	Workers   int  `koanf:"workers" reload:"hot"`
-	Cranelift bool `koanf:"cranelift"`
+	Workers          int           `koanf:"workers" reload:"hot"`
+	Cranelift        bool          `koanf:"cranelift"`
+	MaxExecutionTime time.Duration `koanf:"max-execution-time" reload:"hot"`
 
 	// TODO: change WasmMemoryUsageLimit to a string and use resourcemanager.ParseMemLimit
 	WasmMemoryUsageLimit int `koanf:"wasm-memory-usage-limit"`
@@ -30,6 +31,7 @@ type JitSpawnerConfigFecher func() *JitSpawnerConfig
 var DefaultJitSpawnerConfig = JitSpawnerConfig{
 	Workers:              0,
 	Cranelift:            true,
+	MaxExecutionTime:     time.Minute * 10,
 	WasmMemoryUsageLimit: 4294967296, // 2^32 WASM memeory limit
 }
 
@@ -37,6 +39,7 @@ func JitSpawnerConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Int(prefix+".workers", DefaultJitSpawnerConfig.Workers, "number of concurrent validation threads")
 	f.Bool(prefix+".cranelift", DefaultJitSpawnerConfig.Cranelift, "use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator")
 	f.Int(prefix+".wasm-memory-usage-limit", DefaultJitSpawnerConfig.WasmMemoryUsageLimit, "if memory used by a jit wasm exceeds this limit, a warning is logged")
+	f.Duration(prefix+".max-execution-time", DefaultJitSpawnerConfig.MaxExecutionTime, "if execution time used by a jit wasm exceeds this limit, a rpc error is returned")
 }
 
 type JitSpawner struct {
@@ -52,7 +55,8 @@ func NewJitSpawner(locator *server_common.MachineLocator, config JitSpawnerConfi
 	machineConfig := DefaultJitMachineConfig
 	machineConfig.JitCranelift = config().Cranelift
 	machineConfig.WasmMemoryUsageLimit = config().WasmMemoryUsageLimit
-	loader, err := NewJitMachineLoader(&machineConfig, locator, fatalErrChan)
+	maxExecutionTime := config().MaxExecutionTime
+	loader, err := NewJitMachineLoader(&machineConfig, locator, maxExecutionTime, fatalErrChan)
 	if err != nil {
 		return nil, err
 	}
diff --git a/validator/validation_entry.go b/validator/validation_entry.go
index d340993fa2..4ec6919d3b 100644
--- a/validator/validation_entry.go
+++ b/validator/validation_entry.go
@@ -7,9 +7,8 @@ import (
 )
 
 type BatchInfo struct {
-	Number    uint64
-	BlockHash common.Hash
-	Data      []byte
+	Number uint64
+	Data   []byte
 }
 
 type ValidationInput struct {
diff --git a/validator/valnode/redis/consumer.go b/validator/valnode/redis/consumer.go
index 2b025600cc..e0d53ffb2e 100644
--- a/validator/valnode/redis/consumer.go
+++ b/validator/valnode/redis/consumer.go
@@ -103,11 +103,13 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 			case <-ready: // Wait until the stream exists and start consuming iteratively.
 			}
 			s.StopWaiter.CallIteratively(func(ctx context.Context) time.Duration {
+				log.Debug("waiting for request token", "cid", c.Id())
 				select {
 				case <-ctx.Done():
 					return 0
 				case <-requestTokenQueue:
 				}
+				log.Debug("got request token", "cid", c.Id())
 				req, err := c.Consume(ctx)
 				if err != nil {
 					log.Error("Consuming request", "error", err)
@@ -115,10 +117,12 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 					return 0
 				}
 				if req == nil {
+					log.Debug("consumed nil", "cid", c.Id())
 					// There's nothing in the queue
 					requestTokenQueue <- struct{}{}
 					return time.Second
 				}
+				log.Debug("forwarding work", "cid", c.Id(), "workid", req.ID)
 				select {
 				case <-ctx.Done():
 				case workQueue <- workUnit{req, moduleRoot}:
@@ -131,7 +135,7 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 		for {
 			select {
 			case <-readyStreams:
-				log.Trace("At least one stream is ready")
+				log.Debug("At least one stream is ready")
 				return // Don't block Start if at least one of the stream is ready.
 			case <-time.After(s.config.StreamTimeout):
 				log.Error("Waiting for redis streams timed out")
@@ -142,22 +146,27 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 		}
 	})
 	for i := 0; i < workers; i++ {
+		i := i
 		s.StopWaiter.LaunchThread(func(ctx context.Context) {
 			for {
+				log.Debug("waiting for work", "thread", i)
 				var work workUnit
 				select {
 				case <-ctx.Done():
 					return
 				case work = <-workQueue:
 				}
+				log.Debug("got work", "thread", i, "workid", work.req.ID)
 				valRun := s.spawner.Launch(work.req.Value, work.moduleRoot)
 				res, err := valRun.Await(ctx)
 				if err != nil {
 					log.Error("Error validating", "request value", work.req.Value, "error", err)
 				} else {
+					log.Debug("done work", "thread", i, "workid", work.req.ID)
 					if err := s.consumers[work.moduleRoot].SetResult(ctx, work.req.ID, res); err != nil {
 						log.Error("Error setting result for request", "id", work.req.ID, "result", res, "error", err)
 					}
+					log.Debug("set result", "thread", i, "workid", work.req.ID)
 				}
 				select {
 				case <-ctx.Done():
diff --git a/validator/valnode/validation_api.go b/validator/valnode/validation_api.go
index a10d931dfc..ef3e1b2c49 100644
--- a/validator/valnode/validation_api.go
+++ b/validator/valnode/validation_api.go
@@ -118,15 +118,6 @@ func (a *ExecServerAPI) Start(ctx_in context.Context) {
 	a.CallIteratively(a.removeOldRuns)
 }
 
-func (a *ExecServerAPI) WriteToFile(ctx context.Context, jsonInput *server_api.InputJSON, expOut validator.GoGlobalState, moduleRoot common.Hash) error {
-	input, err := server_api.ValidationInputFromJson(jsonInput)
-	if err != nil {
-		return err
-	}
-	_, err = a.execSpawner.WriteToFile(input, expOut, moduleRoot).Await(ctx)
-	return err
-}
-
 var errRunNotFound error = errors.New("run not found")
 
 func (a *ExecServerAPI) getRun(id uint64) (validator.ExecutionRun, error) {