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/Makefile b/Makefile
index b736b04906..0a71d64f12 100644
--- a/Makefile
+++ b/Makefile
@@ -60,7 +60,7 @@ replay_wasm=$(output_latest)/replay.wasm
 arb_brotli_files = $(wildcard arbitrator/brotli/src/*.* arbitrator/brotli/src/*/*.* arbitrator/brotli/*.toml arbitrator/brotli/*.rs) .make/cbrotli-lib .make/cbrotli-wasm
 
 arbitrator_generated_header=$(output_root)/include/arbitrator.h
-arbitrator_wasm_libs=$(patsubst %, $(output_root)/machines/latest/%.wasm, wasi_stub host_io soft-float arbcompress user_host program_exec)
+arbitrator_wasm_libs=$(patsubst %, $(output_root)/machines/latest/%.wasm, forward wasi_stub host_io soft-float arbcompress user_host program_exec)
 arbitrator_stylus_lib=$(output_root)/lib/libstylus.a
 prover_bin=$(output_root)/bin/prover
 arbitrator_jit=$(output_root)/bin/jit
@@ -75,12 +75,16 @@ arbitrator_test_wasms=$(patsubst %.wat,%.wasm, $(arbitrator_tests_wat)) $(patsub
 arbitrator_tests_link_info = $(shell cat $(arbitrator_cases)/link.txt | xargs)
 arbitrator_tests_link_deps = $(patsubst %,$(arbitrator_cases)/%.wasm, $(arbitrator_tests_link_info))
 
+arbitrator_tests_forward_wats = $(wildcard $(arbitrator_cases)/forward/*.wat)
+arbitrator_tests_forward_deps = $(arbitrator_tests_forward_wats:wat=wasm)
+
 WASI_SYSROOT?=/opt/wasi-sdk/wasi-sysroot
 
 arbitrator_wasm_lib_flags=$(patsubst %, -l %, $(arbitrator_wasm_libs))
 
 rust_arbutil_files = $(wildcard arbitrator/arbutil/src/*.* arbitrator/arbutil/src/*/*.* arbitrator/arbutil/*.toml arbitrator/caller-env/src/*.* arbitrator/caller-env/src/*/*.* arbitrator/caller-env/*.toml) .make/cbrotli-lib
 
+prover_direct_includes = $(patsubst %,$(output_latest)/%.wasm, forward forward_stub)
 prover_dir = arbitrator/prover/
 rust_prover_files = $(wildcard $(prover_dir)/src/*.* $(prover_dir)/src/*/*.* $(prover_dir)/*.toml $(prover_dir)/*.rs) $(rust_arbutil_files) $(prover_direct_includes) $(arb_brotli_files)
 
@@ -88,9 +92,12 @@ wasm_lib = arbitrator/wasm-libraries
 wasm_lib_cargo = $(wasm_lib)/.cargo/config.toml
 wasm_lib_deps = $(wildcard $(wasm_lib)/$(1)/*.toml $(wasm_lib)/$(1)/src/*.rs $(wasm_lib)/$(1)/*.rs) $(wasm_lib_cargo) $(rust_arbutil_files) $(arb_brotli_files) .make/machines
 wasm_lib_go_abi = $(call wasm_lib_deps,go-abi)
+wasm_lib_forward = $(call wasm_lib_deps,forward)
 wasm_lib_user_host_trait = $(call wasm_lib_deps,user-host-trait)
 wasm_lib_user_host = $(call wasm_lib_deps,user-host) $(wasm_lib_user_host_trait)
 
+forward_dir = $(wasm_lib)/forward
+
 stylus_files = $(wildcard $(stylus_dir)/*.toml $(stylus_dir)/src/*.rs) $(wasm_lib_user_host_trait) $(rust_prover_files)
 
 jit_dir = arbitrator/jit
@@ -274,6 +281,7 @@ clean:
 	rm -f arbitrator/wasm-libraries/soft-float/*.o
 	rm -f arbitrator/wasm-libraries/soft-float/SoftFloat/build/Wasm-Clang/*.o
 	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 contracts/build contracts/cache solgen/go/
 	@rm -f .make/*
@@ -391,7 +399,7 @@ $(output_latest)/host_io.wasm: $(DEP_PREDICATE) $(call wasm_lib_deps,host-io) $(
 	cargo build --manifest-path arbitrator/wasm-libraries/Cargo.toml --release --target wasm32-wasi --config $(wasm_lib_cargo) --package host-io
 	install arbitrator/wasm-libraries/$(wasm32_wasi)/host_io.wasm $@
 
-$(output_latest)/user_host.wasm: $(DEP_PREDICATE) $(wasm_lib_user_host) $(rust_prover_files) .make/machines
+$(output_latest)/user_host.wasm: $(DEP_PREDICATE) $(wasm_lib_user_host) $(rust_prover_files) $(output_latest)/forward_stub.wasm .make/machines
 	cargo build --manifest-path arbitrator/wasm-libraries/Cargo.toml --release --target wasm32-wasi --config $(wasm_lib_cargo) --package user-host
 	install arbitrator/wasm-libraries/$(wasm32_wasi)/user_host.wasm $@
 
@@ -407,9 +415,17 @@ $(output_latest)/arbcompress.wasm: $(DEP_PREDICATE) $(call wasm_lib_deps,brotli)
 	cargo build --manifest-path arbitrator/wasm-libraries/Cargo.toml --release --target wasm32-wasi --config $(wasm_lib_cargo) --package arbcompress
 	install arbitrator/wasm-libraries/$(wasm32_wasi)/arbcompress.wasm $@
 
+$(output_latest)/forward.wasm: $(DEP_PREDICATE) $(wasm_lib_forward) .make/machines
+	cargo run --manifest-path $(forward_dir)/Cargo.toml -- --path $(forward_dir)/forward.wat
+	wat2wasm $(wasm_lib)/forward/forward.wat -o $@
+
+$(output_latest)/forward_stub.wasm: $(DEP_PREDICATE) $(wasm_lib_forward) .make/machines
+	cargo run --manifest-path $(forward_dir)/Cargo.toml -- --path $(forward_dir)/forward_stub.wat --stub
+	wat2wasm $(wasm_lib)/forward/forward_stub.wat -o $@
+
 $(output_latest)/machine.wavm.br: $(DEP_PREDICATE) $(prover_bin) $(arbitrator_wasm_libs) $(replay_wasm)
-	$(prover_bin) $(replay_wasm) --generate-binaries $(output_latest) --with-forwarder \
-	$(patsubst %,-l $(output_latest)/%.wasm, soft-float wasi_stub host_io user_host arbcompress program_exec)
+	$(prover_bin) $(replay_wasm) --generate-binaries $(output_latest) \
+	$(patsubst %,-l $(output_latest)/%.wasm, forward soft-float wasi_stub host_io user_host arbcompress program_exec)
 
 $(arbitrator_cases)/%.wasm: $(arbitrator_cases)/%.wat
 	wat2wasm $< -o $@
@@ -476,10 +492,10 @@ target/testdata/preimages.bin:
 	python3 scripts/create-test-preimages.py $@
 
 contracts/test/prover/proofs/rust-%.json: $(arbitrator_cases)/rust/$(wasm32_wasi)/%.wasm $(prover_bin) $(arbitrator_wasm_libs) target/testdata/preimages.bin
-	$(prover_bin) $< $(arbitrator_wasm_lib_flags) -o $@ -b --allow-hostapi --require-success --inbox-add-stub-headers --inbox $(arbitrator_cases)/rust/data/msg0.bin --inbox $(arbitrator_cases)/rust/data/msg1.bin --delayed-inbox $(arbitrator_cases)/rust/data/msg0.bin --delayed-inbox $(arbitrator_cases)/rust/data/msg1.bin --preimages target/testdata/preimages.bin --with-forwarder
+	$(prover_bin) $< $(arbitrator_wasm_lib_flags) -o $@ -b --allow-hostapi --require-success --inbox-add-stub-headers --inbox $(arbitrator_cases)/rust/data/msg0.bin --inbox $(arbitrator_cases)/rust/data/msg1.bin --delayed-inbox $(arbitrator_cases)/rust/data/msg0.bin --delayed-inbox $(arbitrator_cases)/rust/data/msg1.bin --preimages target/testdata/preimages.bin
 
 contracts/test/prover/proofs/go.json: $(arbitrator_cases)/go/testcase.wasm $(prover_bin) $(arbitrator_wasm_libs) target/testdata/preimages.bin $(arbitrator_tests_link_deps) $(arbitrator_cases)/user.wasm
-	$(prover_bin) $< $(arbitrator_wasm_lib_flags) -o $@ -b --require-success --preimages target/testdata/preimages.bin --stylus-modules $(arbitrator_cases)/user.wasm --with-forwarder
+	$(prover_bin) $< $(arbitrator_wasm_lib_flags) -o $@ -b --require-success --preimages target/testdata/preimages.bin  --stylus-modules $(arbitrator_cases)/user.wasm
 
 # avoid testing user.wasm in onestepproofs. It can only run as stylus program.
 contracts/test/prover/proofs/user.json:
@@ -492,6 +508,9 @@ contracts/test/prover/proofs/read-inboxmsg-10.json:
 contracts/test/prover/proofs/global-state.json:
 	echo "[]" > $@
 
+contracts/test/prover/proofs/forward-test.json: $(arbitrator_cases)/forward-test.wasm $(arbitrator_tests_forward_deps) $(prover_bin)
+	$(prover_bin) $< -o $@ --allow-hostapi $(patsubst %,-l %, $(arbitrator_tests_forward_deps))
+
 contracts/test/prover/proofs/link.json: $(arbitrator_cases)/link.wasm $(arbitrator_tests_link_deps) $(prover_bin)
 	$(prover_bin) $< -o $@ --allow-hostapi --stylus-modules $(arbitrator_tests_link_deps) --require-success
 
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..1cfceda6b7 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)
diff --git a/arbitrator/arbutil/src/hostios.rs b/arbitrator/arbutil/src/hostios.rs
deleted file mode 100644
index 05bcb94f73..0000000000
--- a/arbitrator/arbutil/src/hostios.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use std::fmt::Display;
-
-pub enum ParamType {
-    I32,
-    I64,
-}
-
-impl Display for ParamType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use ParamType::*;
-        match self {
-            I32 => write!(f, "i32"),
-            I64 => write!(f, "i64"),
-        }
-    }
-}
-
-use ParamType::*;
-
-/// order matters!
-pub const HOSTIOS: [(&str, &[ParamType], &[ParamType]); 42] = [
-    ("read_args", &[I32], &[]),
-    ("write_result", &[I32, I32], &[]),
-    ("exit_early", &[I32], &[]),
-    ("storage_load_bytes32", &[I32, I32], &[]),
-    ("storage_cache_bytes32", &[I32, I32], &[]),
-    ("storage_flush_cache", &[I32], &[]),
-    ("transient_load_bytes32", &[I32, I32], &[]),
-    ("transient_store_bytes32", &[I32, I32], &[]),
-    ("call_contract", &[I32, I32, I32, I32, I64, I32], &[I32]),
-    ("delegate_call_contract", &[I32, I32, I32, I64, I32], &[I32]),
-    ("static_call_contract", &[I32, I32, I32, I64, I32], &[I32]),
-    ("create1", &[I32, I32, I32, I32, I32], &[]),
-    ("create2", &[I32, I32, I32, I32, I32, I32], &[]),
-    ("read_return_data", &[I32, I32, I32], &[I32]),
-    ("return_data_size", &[], &[I32]),
-    ("emit_log", &[I32, I32, I32], &[]),
-    ("account_balance", &[I32, I32], &[]),
-    ("account_code", &[I32, I32, I32, I32], &[I32]),
-    ("account_code_size", &[I32], &[I32]),
-    ("account_codehash", &[I32, I32], &[]),
-    ("evm_gas_left", &[], &[I64]),
-    ("evm_ink_left", &[], &[I64]),
-    ("block_basefee", &[I32], &[]),
-    ("chainid", &[], &[I64]),
-    ("block_coinbase", &[I32], &[]),
-    ("block_gas_limit", &[], &[I64]),
-    ("block_number", &[], &[I64]),
-    ("block_timestamp", &[], &[I64]),
-    ("contract_address", &[I32], &[]),
-    ("math_div", &[I32, I32], &[]),
-    ("math_mod", &[I32, I32], &[]),
-    ("math_pow", &[I32, I32], &[]),
-    ("math_add_mod", &[I32, I32, I32], &[]),
-    ("math_mul_mod", &[I32, I32, I32], &[]),
-    ("msg_reentrant", &[], &[I32]),
-    ("msg_sender", &[I32], &[]),
-    ("msg_value", &[I32], &[]),
-    ("native_keccak256", &[I32, I32, I32], &[]),
-    ("tx_gas_price", &[I32], &[]),
-    ("tx_ink_price", &[], &[I32]),
-    ("tx_origin", &[I32], &[]),
-    ("pay_for_memory_grow", &[I32], &[]),
-];
diff --git a/arbitrator/arbutil/src/lib.rs b/arbitrator/arbutil/src/lib.rs
index 8d8c1d0fca..9c48a9fefc 100644
--- a/arbitrator/arbutil/src/lib.rs
+++ b/arbitrator/arbutil/src/lib.rs
@@ -6,7 +6,6 @@ pub mod color;
 pub mod crypto;
 pub mod evm;
 pub mod format;
-pub mod hostios;
 pub mod math;
 pub mod operator;
 pub mod pricing;
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 a634dba19e..5475647765 100644
--- a/arbitrator/prover/Cargo.toml
+++ b/arbitrator/prover/Cargo.toml
@@ -47,10 +47,6 @@ enum-iterator = "2.0.1"
 criterion = { version = "0.5.0", features = ["html_reports"] }
 rand = "0.8.4"
 
-[build-dependencies]
-wasmer = { path = "../tools/wasmer/lib/api" }
-arbutil = { path = "../arbutil/" }
-
 [[bench]]
 name = "merkle_bench"
 harness = false
diff --git a/arbitrator/prover/build.rs b/arbitrator/prover/build.rs
deleted file mode 100644
index db0560b2c5..0000000000
--- a/arbitrator/prover/build.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use arbutil::hostios::HOSTIOS;
-use std::{env, fmt::Write, fs, path::Path};
-
-pub fn gen_forwarder(out_path: &Path) {
-    let mut wat = String::new();
-    macro_rules! wln {
-        ($($text:tt)*) => {
-            writeln!(wat, $($text)*).unwrap();
-        };
-    }
-    let s = "    ";
-
-    wln!("(module");
-
-    macro_rules! group {
-        ($list:expr, $kind:expr) => {
-            (!$list.is_empty())
-                .then(|| {
-                    format!(
-                        " ({} {})",
-                        $kind,
-                        $list
-                            .iter()
-                            .map(|x| x.to_string())
-                            .collect::<Vec<_>>()
-                            .join(" ")
-                    )
-                })
-                .unwrap_or_default()
-        };
-    }
-
-    wln!("{s};; symbols to re-export");
-    for (name, ins, outs) in HOSTIOS {
-        let params = group!(ins, "param");
-        let result = group!(outs, "result");
-        wln!(r#"{s}(import "user_host" "{name}" (func $_{name}{params}{result}))"#);
-    }
-    wln!();
-
-    wln!("{s};; reserved offsets for future user_host imports");
-    for i in HOSTIOS.len()..512 {
-        wln!("{s}(func $reserved_{i} unreachable)");
-    }
-    wln!();
-
-    wln!(
-        "{s};; allows user_host to request a trap\n\
-        {s}(global $trap (mut i32) (i32.const 0))\n\
-        {s}(func $check\n\
-        {s}{s}global.get $trap                    ;; see if set\n\
-        {s}{s}(global.set $trap (i32.const 0))    ;; reset the flag\n\
-        {s}{s}(if (then (unreachable)))\n\
-        {s})\n\
-        {s}(func (export \"forward__set_trap\")\n\
-        {s}{s}(global.set $trap (i32.const 1))\n\
-        {s})\n"
-    );
-
-    wln!("{s};; user linkage");
-    for (name, ins, outs) in HOSTIOS {
-        let params = group!(ins, "param");
-        let result = group!(outs, "result");
-        wln!("{s}(func (export \"vm_hooks__{name}\"){params}{result}");
-
-        for i in 0..ins.len() {
-            wln!("{s}{s}local.get {i}");
-        }
-
-        wln!(
-            "{s}{s}call $_{name}\n\
-             {s}{s}call $check\n\
-             {s})"
-        );
-    }
-
-    wln!(")");
-    eprintln!("{}", &wat);
-
-    let wasm = wasmer::wat2wasm(wat.as_bytes()).unwrap();
-
-    fs::write(out_path, wasm.as_ref()).unwrap();
-}
-
-fn main() {
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let forwarder_path = Path::new(&out_dir).join("forwarder.wasm");
-    gen_forwarder(&forwarder_path);
-}
diff --git a/arbitrator/prover/src/binary.rs b/arbitrator/prover/src/binary.rs
index b1d819deb2..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::{
@@ -471,14 +473,10 @@ pub fn parse<'a>(input: &'a [u8], path: &'_ Path) -> Result<WasmBinary<'a>> {
         let export = export.rsplit("__").take(1);
         exports.extend(export);
     }
-    // forwarder is allowed to re-export the same name
-    // TODO: is there a real problem if import_name == export_name but module names don't?
-    if path != Path::new("forwarder") {
-        for import in &binary.imports {
-            let name = import.name;
-            if exports.contains(name) {
-                bail!("binary exports an import with the same name {}", name.red());
-            }
+    for import in &binary.imports {
+        let name = import.name;
+        if exports.contains(name) {
+            bail!("binary exports an import with the same name {}", name.red());
         }
     }
 
@@ -645,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,
@@ -682,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/host.rs b/arbitrator/prover/src/host.rs
index dc0f0b74b2..1d0fe658ec 100644
--- a/arbitrator/prover/src/host.rs
+++ b/arbitrator/prover/src/host.rs
@@ -405,7 +405,7 @@ impl Hostio {
     }
 }
 
-pub fn get_impl(module: &str, name: &str) -> Result<Function> {
+pub fn get_impl(module: &str, name: &str) -> Result<(Function, bool)> {
     let hostio: Hostio = format!("{module}__{name}").parse()?;
 
     let append = |code: &mut Vec<Instruction>| {
@@ -414,11 +414,8 @@ pub fn get_impl(module: &str, name: &str) -> Result<Function> {
         Ok(())
     };
 
-    Function::new(&[], append, hostio.ty(), &[])
-}
-
-pub fn hostio_module_is_debug(module: &str) -> bool {
-    module == "console" || module == "debug"
+    let debug = module == "console" || module == "debug";
+    Function::new(&[], append, hostio.ty(), &[]).map(|x| (x, debug))
 }
 
 /// Adds internal functions to a module.
diff --git a/arbitrator/prover/src/lib.rs b/arbitrator/prover/src/lib.rs
index e45d12c492..0f537478eb 100644
--- a/arbitrator/prover/src/lib.rs
+++ b/arbitrator/prover/src/lib.rs
@@ -70,16 +70,10 @@ pub unsafe extern "C" fn arbitrator_load_machine(
     library_paths: *const *const c_char,
     library_paths_size: isize,
     debug_chain: usize,
-    with_forwarder: bool,
 ) -> *mut Machine {
     let debug_chain = debug_chain != 0;
-    match arbitrator_load_machine_impl(
-        binary_path,
-        library_paths,
-        library_paths_size,
-        debug_chain,
-        with_forwarder,
-    ) {
+    match arbitrator_load_machine_impl(binary_path, library_paths, library_paths_size, debug_chain)
+    {
         Ok(mach) => mach,
         Err(err) => {
             eprintln!("Error loading binary: {:?}", err);
@@ -93,7 +87,6 @@ unsafe fn arbitrator_load_machine_impl(
     library_paths: *const *const c_char,
     library_paths_size: isize,
     debug_chain: bool,
-    with_forwarder: bool,
 ) -> Result<*mut Machine> {
     let binary_path = cstr_to_string(binary_path);
     let binary_path = Path::new(&binary_path);
@@ -114,7 +107,6 @@ unsafe fn arbitrator_load_machine_impl(
         Default::default(),
         Default::default(),
         get_empty_preimage_resolver(),
-        with_forwarder,
     )?;
     Ok(Box::into_raw(Box::new(mach)))
 }
diff --git a/arbitrator/prover/src/machine.rs b/arbitrator/prover/src/machine.rs
index 2418d3cc2e..4ece1f7bf2 100644
--- a/arbitrator/prover/src/machine.rs
+++ b/arbitrator/prover/src/machine.rs
@@ -19,7 +19,7 @@ use crate::{
         IBinOpType, IRelOpType, IUnOpType, Instruction, Opcode,
     },
 };
-use arbutil::{crypto, hostios::HOSTIOS, math, Bytes32, Color, DebugColor, PreimageType};
+use arbutil::{crypto, math, Bytes32, Color, DebugColor, PreimageType};
 use brotli::Dictionary;
 #[cfg(feature = "native")]
 use c_kzg::BYTES_PER_BLOB;
@@ -330,115 +330,36 @@ pub struct Module {
     pub(crate) extra_hash: Arc<Bytes32>,
 }
 
-#[cfg(feature = "native")]
-static FORWARDER_WASM: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/forwarder.wasm"));
-
 lazy_static! {
     static ref USER_IMPORTS: HashMap<String, AvailableImport> = {
         let mut imports = HashMap::default();
 
-        // 0-513 are internal
-        for (index, (name, ins, outs)) in HOSTIOS.iter().enumerate() {
-            let import = AvailableImport::new(FunctionType::new(ins.iter().map(|x|x.into()).collect::<Vec<_>>(), outs.iter().map(|x|x.into()).collect::<Vec<_>>()), 1, (index + 514).try_into().unwrap());
-            imports.insert(format!("vm_hooks__{name}"), import);
-        }
-        imports
-    };
-}
+        let forward = include_bytes!("../../../target/machines/latest/forward_stub.wasm");
+        let forward = binary::parse(forward, Path::new("forward")).unwrap();
 
-trait ImportResolver: for<'a, 'b> Fn(&'a str, &'b str) -> Result<Function> + Sized {
-    fn compose(self, other: impl ImportResolver) -> impl ImportResolver {
-        move |module, name| {
-            self(module, name).or_else(|original_err| {
-                let mut result = other(module, name);
-                if result.is_err() {
-                    for err_layer in original_err.chain().rev() {
-                        result = result.wrap_err(format!("{err_layer}"));
-                    }
-                }
-                result
-            })
-        }
-    }
-
-    fn condition(self, condition: bool) -> impl ImportResolver {
-        move |module, name| {
-            if condition {
-                self(module, name)
-            } else {
-                bail!("resolver disabled")
+        for (name, &(export, kind)) in &forward.exports {
+            if kind == ExportKind::Func {
+                let ty = match forward.get_function(FunctionIndex::from_u32(export)) {
+                    Ok(ty) => ty,
+                    Err(error) => panic!("failed to read export {name}: {error:?}"),
+                };
+                let import = AvailableImport::new(ty, 1, export);
+                imports.insert(name.to_owned(), import);
             }
         }
-    }
+        imports
+    };
 }
 
-impl<F: for<'a, 'b> Fn(&'a str, &'b str) -> Result<Function>> ImportResolver for F {}
-
 impl Module {
-    fn make_imports_resolver(
-        import_map: &HashMap<String, AvailableImport>,
-    ) -> impl ImportResolver + '_ {
-        move |module, name| {
-            let qualified_name = format!("{module}__{name}");
-
-            let Some(import) = import_map.get(&qualified_name) else {
-                bail!("func not found {module} {name}")
-            };
-            let wavm = vec![
-                Instruction::simple(Opcode::InitFrame),
-                Instruction::with_data(
-                    Opcode::CrossModuleCall,
-                    pack_cross_module_call(import.module, import.func),
-                ),
-                Instruction::simple(Opcode::Return),
-            ];
-            Ok(Function::new_from_wavm(wavm, import.ty.clone(), vec![]))
-        }
-    }
-
-    fn make_forward_resolver(
-        import_map: &HashMap<String, AvailableImport>,
-    ) -> impl ImportResolver + '_ {
-        move |module, name| {
-            let qualified_name = format!("{module}__{name}");
-
-            let Some(import) = import_map.get(&qualified_name) else {
-                bail!("func not found {module} {name}")
-            };
-            let wavm = vec![
-                Instruction::simple(Opcode::InitFrame),
-                Instruction::with_data(
-                    Opcode::CrossModuleForward,
-                    pack_cross_module_call(import.module, import.func),
-                ),
-                Instruction::simple(Opcode::Return),
-            ];
-            Ok(Function::new_from_wavm(wavm, import.ty.clone(), vec![]))
-        }
-    }
+    const FORWARDING_PREFIX: &'static str = "arbitrator_forward__";
 
-    fn hostio_resolver(module: &str, name: &str) -> Result<Function> {
-        if host::hostio_module_is_debug(module) {
-            return Self::notfound_resolver(module, name);
-        }
-        host::get_impl(module, name)
-    }
-
-    fn debug_resolver(module: &str, name: &str) -> Result<Function> {
-        if !host::hostio_module_is_debug(module) {
-            return Self::notfound_resolver(module, name);
-        }
-        host::get_impl(module, name)
-    }
-
-    fn notfound_resolver(module: &str, name: &str) -> Result<Function> {
-        bail!("import not found {module} {name}")
-    }
-
-    fn from_binary<R: ImportResolver>(
+    fn from_binary(
         bin: &WasmBinary,
-        import_resolver: R,
+        available_imports: &HashMap<String, AvailableImport>,
         floating_point_impls: &FloatingPointImpls,
+        allow_hostapi: bool,
+        debug_funcs: bool,
         stylus_data: Option<StylusData>,
     ) -> Result<Module> {
         let mut code = Vec::new();
@@ -450,18 +371,56 @@ impl Module {
         for import in &bin.imports {
             let module = import.module;
             let have_ty = &bin.types[import.offset as usize];
+            // 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 func = import_resolver(import.module, import.name)?;
+            let qualified_name = format!("{module}__{import_name}");
 
+            let func = if let Some(import) = available_imports.get(&qualified_name) {
+                let call = match forward {
+                    true => Opcode::CrossModuleForward,
+                    false => Opcode::CrossModuleCall,
+                };
+                let wavm = vec![
+                    Instruction::simple(Opcode::InitFrame),
+                    Instruction::with_data(
+                        call,
+                        pack_cross_module_call(import.module, import.func),
+                    ),
+                    Instruction::simple(Opcode::Return),
+                ];
+                Function::new_from_wavm(wavm, import.ty.clone(), vec![])
+            } else if let Ok((hostio, debug)) = host::get_impl(import.module, import_name) {
+                ensure!(
+                    (debug && debug_funcs) || (!debug && allow_hostapi),
+                    "Host func {} in {} not enabled debug_funcs={debug_funcs} hostapi={allow_hostapi} debug={debug}",
+                    import_name.red(),
+                    import.module.red(),
+                );
+                hostio
+            } else {
+                bail!(
+                    "No such import {} in {} for {}",
+                    import_name.red(),
+                    import.module.red(),
+                    bin_name.red()
+                )
+            };
             ensure!(
                 &func.ty == have_ty,
                 "Import {} for {} has different function signature than export.\nexpected {} in {}\nbut have {}",
-                import.name.red(), bin_name.red(), func.ty.red(), module.red(), have_ty.red(),
+                import_name.red(), bin_name.red(), func.ty.red(), module.red(), have_ty.red(),
             );
 
             func_type_idxs.push(import.offset);
             code.push(func);
-            host_call_hooks.push(Some((import.module.into(), import.name.into())));
+            host_call_hooks.push(Some((import.module.into(), import_name.into())));
         }
         func_type_idxs.extend(bin.functions.iter());
 
@@ -657,9 +616,10 @@ impl Module {
     ) -> Result<Module> {
         Self::from_binary(
             bin,
-            Module::make_imports_resolver(&USER_IMPORTS)
-                .compose(Module::debug_resolver.condition(debug_funcs)),
+            &USER_IMPORTS,
             &HashMap::default(),
+            false,
+            debug_funcs,
             stylus_data,
         )
     }
@@ -1270,7 +1230,6 @@ impl Machine {
         global_state: GlobalState,
         inbox_contents: HashMap<(InboxIdentifier, u64), Vec<u8>>,
         preimage_resolver: PreimageResolver,
-        with_forwarder: bool,
     ) -> Result<Machine> {
         let bin_source = file_bytes(binary_path)?;
         let bin = parse(&bin_source, binary_path)
@@ -1296,7 +1255,6 @@ impl Machine {
             inbox_contents,
             preimage_resolver,
             None,
-            with_forwarder,
         )
     }
 
@@ -1326,7 +1284,6 @@ impl Machine {
             HashMap::default(),
             Arc::new(|_, _, _| panic!("tried to read preimage")),
             Some(stylus_data),
-            false,
         )?;
 
         let footprint: u32 = stylus_data.footprint.into();
@@ -1374,7 +1331,6 @@ impl Machine {
         inbox_contents: HashMap<(InboxIdentifier, u64), Vec<u8>>,
         preimage_resolver: PreimageResolver,
         stylus_data: Option<StylusData>,
-        with_forwarder: bool,
     ) -> Result<Machine> {
         use ArbValueType::*;
 
@@ -1382,19 +1338,25 @@ impl Machine {
         let mut modules = vec![Module::default()];
         let mut available_imports = HashMap::default();
         let mut floating_point_impls = HashMap::default();
-
-        let forwarder = if with_forwarder {
-            #[cfg(not(feature = "native"))]
-            bail!("forwarder not supported without native");
-
-            #[cfg(feature = "native")]
-            Some(parse(FORWARDER_WASM, Path::new("forwarder"))?)
-        } else {
-            None
-        };
+        let main_module_index = u32::try_from(modules.len() + libraries.len())?;
+
+        // make the main module's exports available to libraries
+        for (name, &(export, kind)) in &bin.exports {
+            if kind == ExportKind::Func {
+                let index: usize = export.try_into()?;
+                if let Some(index) = index.checked_sub(bin.imports.len()) {
+                    let ty: usize = bin.functions[index].try_into()?;
+                    let ty = bin.types[ty].clone();
+                    available_imports.insert(
+                        format!("env__wavm_guest_call__{name}"),
+                        AvailableImport::new(ty, main_module_index, export),
+                    );
+                }
+            }
+        }
 
         // collect all the library exports in advance so they can use each other's
-        for (index, lib) in forwarder.iter().chain(libraries.iter()).enumerate() {
+        for (index, lib) in libraries.iter().enumerate() {
             let module = 1 + index as u32; // off by one due to the entry point
             for (name, &(export, kind)) in &lib.exports {
                 if kind == ExportKind::Func {
@@ -1402,57 +1364,54 @@ impl Machine {
                         Ok(ty) => ty,
                         Err(error) => bail!("failed to read export {name}: {error}"),
                     };
-                    let import = AvailableImport::new(ty.clone(), module, export);
+                    let import = AvailableImport::new(ty, module, export);
                     available_imports.insert(name.to_owned(), import);
-                    if let Ok(op) = name.parse::<FloatInstruction>() {
-                        let mut sig = op.signature();
-                        // wavm codegen takes care of effecting this type change at callsites
-                        for ty in sig.inputs.iter_mut().chain(sig.outputs.iter_mut()) {
-                            if *ty == F32 {
-                                *ty = I32;
-                            } else if *ty == F64 {
-                                *ty = I64;
-                            }
-                        }
-                        ensure!(
-                            ty == sig,
-                            "Wrong type for floating point impl {} expecting {} but got {}",
-                            name.red(),
-                            sig.red(),
-                            ty.red()
-                        );
-                        floating_point_impls.insert(op, (module, export));
-                    }
                 }
             }
         }
 
-        if let Some(lib) = forwarder {
-            modules.push(Module::from_binary(
-                &lib,
-                Module::make_forward_resolver(&available_imports),
-                &floating_point_impls,
-                None,
-            )?);
-        }
-
-        for lib in libraries.iter() {
-            modules.push(Module::from_binary(
+        for lib in libraries {
+            let module = Module::from_binary(
                 lib,
-                Module::hostio_resolver
-                    .compose(Module::debug_resolver.condition(debug_funcs))
-                    .compose(Module::make_imports_resolver(&available_imports)),
+                &available_imports,
                 &floating_point_impls,
+                true,
+                debug_funcs,
                 None,
-            )?);
+            )?;
+            for (name, &func) in &*module.func_exports {
+                let ty = module.func_types[func as usize].clone();
+                if let Ok(op) = name.parse::<FloatInstruction>() {
+                    let mut sig = op.signature();
+                    // wavm codegen takes care of effecting this type change at callsites
+                    for ty in sig.inputs.iter_mut().chain(sig.outputs.iter_mut()) {
+                        if *ty == F32 {
+                            *ty = I32;
+                        } else if *ty == F64 {
+                            *ty = I64;
+                        }
+                    }
+                    ensure!(
+                        ty == sig,
+                        "Wrong type for floating point impl {} expecting {} but got {}",
+                        name.red(),
+                        sig.red(),
+                        ty.red()
+                    );
+                    floating_point_impls.insert(op, (modules.len() as u32, func));
+                }
+            }
+            modules.push(module);
         }
 
+        // Shouldn't be necessary, but to be safe, don't allow the main binary to import its own guest calls
+        available_imports.retain(|_, i| i.module as usize != modules.len());
         modules.push(Module::from_binary(
             &bin,
-            Module::make_imports_resolver(&available_imports)
-                .compose(Module::hostio_resolver.condition(allow_hostapi_from_main))
-                .compose(Module::debug_resolver.condition(debug_funcs)),
+            &available_imports,
             &floating_point_impls,
+            allow_hostapi_from_main,
+            debug_funcs,
             stylus_data,
         )?);
 
diff --git a/arbitrator/prover/src/main.rs b/arbitrator/prover/src/main.rs
index 442b35992d..dba32e0e72 100644
--- a/arbitrator/prover/src/main.rs
+++ b/arbitrator/prover/src/main.rs
@@ -86,8 +86,6 @@ struct Opts {
     skip_until_host_io: bool,
     #[structopt(long)]
     max_steps: Option<u64>,
-    #[structopt(short, long)]
-    with_forwarder: bool,
 }
 
 fn file_with_stub_header(path: &Path, headerlength: usize) -> Result<Vec<u8>> {
@@ -213,7 +211,6 @@ fn main() -> Result<()> {
         global_state,
         inbox_contents,
         preimage_resolver,
-        opts.with_forwarder,
     )?;
 
     for path in &opts.stylus_modules {
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/prover/src/test.rs b/arbitrator/prover/src/test.rs
index 2f32aff012..97170441ff 100644
--- a/arbitrator/prover/src/test.rs
+++ b/arbitrator/prover/src/test.rs
@@ -57,7 +57,7 @@ pub fn reject_ambiguous_imports() {
 
 #[test]
 pub fn test_compress() -> Result<()> {
-    let data = include_bytes!(concat!(env!("OUT_DIR"), "/forwarder.wasm"));
+    let data = include_bytes!("../../../target/machines/latest/forward_stub.wasm");
     let mut last = vec![];
 
     for dict in [Dictionary::Empty, Dictionary::StylusProgram] {
diff --git a/arbitrator/prover/src/value.rs b/arbitrator/prover/src/value.rs
index f2f54404f0..6afffdf7a0 100644
--- a/arbitrator/prover/src/value.rs
+++ b/arbitrator/prover/src/value.rs
@@ -2,7 +2,7 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
 use crate::binary::FloatType;
-use arbutil::{hostios::ParamType, Bytes32, Color};
+use arbutil::{Bytes32, Color};
 use digest::Digest;
 use eyre::{bail, ErrReport, Result};
 use serde::{Deserialize, Serialize};
@@ -77,16 +77,6 @@ impl From<ArbValueType> for ValType {
     }
 }
 
-impl From<&ParamType> for ArbValueType {
-    fn from(ty: &ParamType) -> Self {
-        use ParamType as V;
-        match ty {
-            V::I32 => Self::I32,
-            V::I64 => Self::I64,
-        }
-    }
-}
-
 #[cfg(feature = "native")]
 pub fn parser_type(ty: &wasmer::Type) -> wasmer::wasmparser::ValType {
     match ty {
diff --git a/arbitrator/prover/test-cases/forward-test.wat b/arbitrator/prover/test-cases/forward-test.wat
new file mode 100644
index 0000000000..b9beff0d82
--- /dev/null
+++ b/arbitrator/prover/test-cases/forward-test.wat
@@ -0,0 +1,32 @@
+
+(module
+    (import "forward" "add" (func $add (param i32 i32) (result i32)))
+    (import "forward" "sub" (func $sub (param i32 i32) (result i32)))
+    (import "forward" "mul" (func $mul (param i32 i32) (result i32)))
+    (func $start
+        ;; this address will update each time a forwarded call is made
+        i32.const 0xa4b
+        i32.const 805
+        i32.store
+
+        i32.const 11
+        i32.const 5
+        call $sub
+
+        i32.const 3
+        i32.const -2
+        call $mul
+
+        call $add
+        (if
+            (then (unreachable)))
+
+        ;; check that the address has changed
+        i32.const 0xa4b
+        i32.load
+        i32.const 808
+        i32.ne
+        (if
+            (then (unreachable))))
+    (start $start)
+    (memory 1))
diff --git a/arbitrator/prover/test-cases/forward/forward.wat b/arbitrator/prover/test-cases/forward/forward.wat
new file mode 100644
index 0000000000..ff55953e62
--- /dev/null
+++ b/arbitrator/prover/test-cases/forward/forward.wat
@@ -0,0 +1,8 @@
+
+(module
+    (import "target" "arbitrator_forward__add" (func $add (param i32 i32) (result i32)))
+    (import "target" "arbitrator_forward__sub" (func $sub (param i32 i32) (result i32)))
+    (import "target" "arbitrator_forward__mul" (func $mul (param i32 i32) (result i32)))
+    (export "forward__add" (func $add))
+    (export "forward__sub" (func $sub))
+    (export "forward__mul" (func $mul)))
diff --git a/arbitrator/prover/test-cases/forward/target.wat b/arbitrator/prover/test-cases/forward/target.wat
new file mode 100644
index 0000000000..0779eb753d
--- /dev/null
+++ b/arbitrator/prover/test-cases/forward/target.wat
@@ -0,0 +1,27 @@
+
+(module
+    (import "env" "wavm_caller_load8" (func $load (param i32) (result i32)))
+    (import "env" "wavm_caller_store8" (func $store (param i32 i32)))
+    (func (export "target__add") (param i32 i32) (result i32)
+        call $write_caller
+        local.get 0
+        local.get 1
+        i32.add)
+    (func (export "target__sub") (param i32 i32) (result i32)
+        call $write_caller
+        local.get 0
+        local.get 1
+        i32.sub)
+    (func (export "target__mul") (param i32 i32) (result i32)
+        call $write_caller
+        local.get 0
+        local.get 1
+        i32.mul)
+    (func $write_caller (export "write_caller")
+        ;; increment the value at address 0xa4b in the caller
+        i32.const 0xa4b
+        i32.const 0xa4b
+        call $load
+        i32.const 1
+        i32.add
+        call $store))
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..052bfc7229 100644
--- a/arbitrator/stylus/src/lib.rs
+++ b/arbitrator/stylus/src/lib.rs
@@ -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),
     };
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/mod.rs b/arbitrator/stylus/src/test/mod.rs
index 42c9446564..00c9c62ae4 100644
--- a/arbitrator/stylus/src/test/mod.rs
+++ b/arbitrator/stylus/src/test/mod.rs
@@ -164,7 +164,6 @@ fn new_test_machine(path: &str, compile: &CompileConfig) -> Result<Machine> {
         HashMap::default(),
         Arc::new(|_, _, _| panic!("tried to read preimage")),
         Some(stylus_data),
-        false,
     )?;
     mach.set_ink(u64::MAX);
     mach.set_stack(u32::MAX);
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/tools/module_roots/src/main.rs b/arbitrator/tools/module_roots/src/main.rs
index fc22bed5fa..32e4764847 100644
--- a/arbitrator/tools/module_roots/src/main.rs
+++ b/arbitrator/tools/module_roots/src/main.rs
@@ -39,7 +39,6 @@ fn main() -> Result<()> {
         GlobalState::default(),
         HashMap::default(),
         Arc::new(|_, _, _| panic!("tried to read preimage")),
-        false,
     )?;
 
     let mut stylus = vec![];
diff --git a/arbitrator/wasm-libraries/Cargo.lock b/arbitrator/wasm-libraries/Cargo.lock
index b234424f69..7620ff538b 100644
--- a/arbitrator/wasm-libraries/Cargo.lock
+++ b/arbitrator/wasm-libraries/Cargo.lock
@@ -2,21 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "addr2line"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
-dependencies = [
- "gimli 0.29.0",
-]
-
-[[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
 [[package]]
 name = "ahash"
 version = "0.7.8"
@@ -106,21 +91,6 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
-[[package]]
-name = "backtrace"
-version = "0.3.73"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
-dependencies = [
- "addr2line",
- "cc",
- "cfg-if 1.0.0",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
-]
-
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -217,12 +187,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
 [[package]]
 name = "bytes"
 version = "1.7.0"
@@ -239,15 +203,6 @@ dependencies = [
  "rand_pcg",
 ]
 
-[[package]]
-name = "cc"
-version = "1.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57b6a275aa2903740dc87da01c62040406b8812552e97129a63ea8850a17c6e6"
-dependencies = [
- "shlex",
-]
-
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -281,19 +236,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
-[[package]]
-name = "corosensei"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e"
-dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
- "libc",
- "scopeguard",
- "windows-sys 0.33.0",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -303,123 +245,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "cranelift-bforest"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a2ab4512dfd3a6f4be184403a195f76e81a8a9f9e6c898e19d2dc3ce20e0115"
-dependencies = [
- "cranelift-entity",
-]
-
-[[package]]
-name = "cranelift-codegen"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98b022ed2a5913a38839dfbafe6cf135342661293b08049843362df4301261dc"
-dependencies = [
- "arrayvec",
- "bumpalo",
- "cranelift-bforest",
- "cranelift-codegen-meta",
- "cranelift-codegen-shared",
- "cranelift-egraph",
- "cranelift-entity",
- "cranelift-isle",
- "gimli 0.26.2",
- "log",
- "regalloc2",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-codegen-meta"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "639307b45434ad112a98f8300c0f0ab085cbefcd767efcdef9ef19d4c0756e74"
-dependencies = [
- "cranelift-codegen-shared",
-]
-
-[[package]]
-name = "cranelift-codegen-shared"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278e52e29c53fcf32431ef08406c295699a70306d05a0715c5b1bf50e33a9ab7"
-
-[[package]]
-name = "cranelift-egraph"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624b54323b06e675293939311943ba82d323bb340468ce1889be5da7932c8d73"
-dependencies = [
- "cranelift-entity",
- "fxhash",
- "hashbrown 0.12.3",
- "indexmap 1.9.3",
- "log",
- "smallvec",
-]
-
-[[package]]
-name = "cranelift-entity"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a59bcbca89c3f1b70b93ab3cbba5e5e0cbf3e63dadb23c7525cb142e21a9d4c"
-
-[[package]]
-name = "cranelift-frontend"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d70abacb8cfef3dc8ff7e8836e9c1d70f7967dfdac824a4cd5e30223415aca6"
-dependencies = [
- "cranelift-codegen",
- "log",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-isle"
-version = "0.91.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "393bc73c451830ff8dbb3a07f61843d6cb41a084f9996319917c0b291ed785bb"
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
-
 [[package]]
 name = "crunchy"
 version = "0.2.2"
@@ -505,19 +330,6 @@ dependencies = [
  "syn 2.0.72",
 ]
 
-[[package]]
-name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.14.5",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
 [[package]]
 name = "derivative"
 version = "2.2.0"
@@ -644,33 +456,26 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "fallible-iterator"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
-
 [[package]]
 name = "fnv"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "forward"
+version = "0.1.0"
+dependencies = [
+ "eyre",
+ "structopt",
+]
+
 [[package]]
 name = "funty"
 version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -692,23 +497,6 @@ dependencies = [
  "wasi",
 ]
 
-[[package]]
-name = "gimli"
-version = "0.26.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
-dependencies = [
- "fallible-iterator",
- "indexmap 1.9.3",
- "stable_deref_trait",
-]
-
-[[package]]
-name = "gimli"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
-
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -807,15 +595,6 @@ 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"
@@ -853,12 +632,6 @@ 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"
@@ -868,57 +641,12 @@ dependencies = [
  "hashbrown 0.14.5",
 ]
 
-[[package]]
-name = "mach"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "mach2"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
-[[package]]
-name = "memmap2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "memmap2"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d28bba84adfe6646737845bc5ebbfa2c08424eb1c37e94a1fd2a82adb56a872"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "memory_units"
 version = "0.4.0"
@@ -931,15 +659,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
-[[package]]
-name = "miniz_oxide"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
-dependencies = [
- "adler",
-]
-
 [[package]]
 name = "more-asserts"
 version = "0.2.2"
@@ -1072,15 +791,6 @@ dependencies = [
  "syn 2.0.72",
 ]
 
-[[package]]
-name = "object"
-version = "0.36.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "084f1a5821ac4c651660a94a7153d27ac9d8a53736203f58b31945ded098070a"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.19.0"
@@ -1122,12 +832,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
-[[package]]
-name = "pin-project-lite"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
-
 [[package]]
 name = "proc-macro-crate"
 version = "3.1.0"
@@ -1208,7 +912,6 @@ dependencies = [
  "smallvec",
  "static_assertions",
  "structopt",
- "wasmer",
  "wasmer-types",
  "wasmparser",
  "wat",
@@ -1273,26 +976,6 @@ dependencies = [
  "rand_core",
 ]
 
-[[package]]
-name = "rayon"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
-dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.3"
@@ -1302,30 +985,6 @@ dependencies = [
  "bitflags 2.6.0",
 ]
 
-[[package]]
-name = "regalloc2"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "300d4fbfb40c1c66a78ba3ddd41c1110247cf52f97b87d0f2fc9209bd49b030c"
-dependencies = [
- "fxhash",
- "log",
- "slice-group-by",
- "smallvec",
-]
-
-[[package]]
-name = "region"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6b6ebd13bc009aef9cd476c1310d49ac354d36e240cf1bd753290f3dc7199a7"
-dependencies = [
- "bitflags 1.3.2",
- "libc",
- "mach2",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "rend"
 version = "0.4.2"
@@ -1416,12 +1075,6 @@ version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
 
-[[package]]
-name = "self_cell"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d369a96f978623eb3dc28807c4852d6cc617fed53da5d3c400feff1ef34a714a"
-
 [[package]]
 name = "semver"
 version = "1.0.23"
@@ -1437,17 +1090,6 @@ dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "serde-wasm-bindgen"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
-dependencies = [
- "js-sys",
- "serde",
- "wasm-bindgen",
-]
-
 [[package]]
 name = "serde_derive"
 version = "1.0.204"
@@ -1539,22 +1181,6 @@ dependencies = [
  "keccak",
 ]
 
-[[package]]
-name = "shared-buffer"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6c99835bad52957e7aa241d3975ed17c1e5f8c92026377d117a606f36b84b16"
-dependencies = [
- "bytes",
- "memmap2 0.6.2",
-]
-
-[[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"
@@ -1567,12 +1193,6 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
-[[package]]
-name = "slice-group-by"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
-
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -1582,12 +1202,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -1734,37 +1348,6 @@ dependencies = [
  "winnow",
 ]
 
-[[package]]
-name = "tracing"
-version = "0.1.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
-dependencies = [
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.72",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
-dependencies = [
- "once_cell",
-]
-
 [[package]]
 name = "typenum"
 version = "1.17.0"
@@ -1862,147 +1445,13 @@ 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.32.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ba64e81215916eaeb48fee292f29401d69235d62d8b8fd92a7b2844ec5ae5f7"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wasmer"
-version = "4.2.8"
+checksum = "4fb56df3e06b8e6b77e37d2969a50ba51281029a9aeb3855e76b7f49b6418847"
 dependencies = [
- "bytes",
- "cfg-if 1.0.0",
- "derivative",
- "indexmap 1.9.3",
- "js-sys",
- "more-asserts",
- "rustc-demangle",
- "serde",
- "serde-wasm-bindgen",
- "shared-buffer",
- "target-lexicon",
- "thiserror",
- "tracing",
- "wasm-bindgen",
- "wasmer-compiler",
- "wasmer-compiler-cranelift",
- "wasmer-derive",
- "wasmer-types",
- "wasmer-vm",
- "wat",
- "winapi",
-]
-
-[[package]]
-name = "wasmer-compiler"
-version = "4.2.8"
-dependencies = [
- "backtrace",
- "bytes",
- "cfg-if 1.0.0",
- "enum-iterator 0.7.0",
- "enumset",
- "lazy_static",
  "leb128",
- "memmap2 0.5.10",
- "more-asserts",
- "region",
- "rkyv",
- "self_cell",
- "shared-buffer",
- "smallvec",
- "thiserror",
- "wasmer-types",
- "wasmer-vm",
- "wasmparser",
- "winapi",
-]
-
-[[package]]
-name = "wasmer-compiler-cranelift"
-version = "4.2.8"
-dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "gimli 0.26.2",
- "more-asserts",
- "rayon",
- "smallvec",
- "target-lexicon",
- "tracing",
- "wasmer-compiler",
- "wasmer-types",
-]
-
-[[package]]
-name = "wasmer-derive"
-version = "4.2.8"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
 ]
 
 [[package]]
@@ -2019,32 +1468,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "wasmer-vm"
-version = "4.2.8"
-dependencies = [
- "backtrace",
- "cc",
- "cfg-if 1.0.0",
- "corosensei",
- "crossbeam-queue",
- "dashmap",
- "derivative",
- "enum-iterator 0.7.0",
- "fnv",
- "indexmap 1.9.3",
- "lazy_static",
- "libc",
- "mach",
- "memoffset",
- "more-asserts",
- "region",
- "scopeguard",
- "thiserror",
- "wasmer-types",
- "winapi",
-]
-
 [[package]]
 name = "wasmparser"
 version = "0.121.2"
@@ -2058,10 +1481,11 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "64.0.0"
+version = "215.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a259b226fd6910225aa7baeba82f9d9933b6d00f2ce1b49b80fa4214328237cc"
+checksum = "1ff1d00d893593249e60720be04a7c1f42f1c4dc3806a2869f4e66ab61eb54cb"
 dependencies = [
+ "bumpalo",
  "leb128",
  "memchr",
  "unicode-width",
@@ -2070,9 +1494,9 @@ dependencies = [
 
 [[package]]
 name = "wat"
-version = "1.0.71"
+version = "1.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53253d920ab413fca1c7dc2161d601c79b4fdf631d0ba51dd4343bf9b556c3f6"
+checksum = "670bf4d9c8cf76ae242d70ded47c546525b6dafaa6871f9bcb065344bf2b4e3d"
 dependencies = [
  "wast",
 ]
@@ -2111,28 +1535,6 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows-sys"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75"
-dependencies = [
- "windows_aarch64_msvc 0.33.0",
- "windows_i686_gnu 0.33.0",
- "windows_i686_msvc 0.33.0",
- "windows_x86_64_gnu 0.33.0",
- "windows_x86_64_msvc 0.33.0",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
-dependencies = [
- "windows-targets",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -2140,13 +1542,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
  "windows_aarch64_gnullvm",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
  "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
  "windows_x86_64_gnullvm",
- "windows_x86_64_msvc 0.52.6",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
@@ -2155,24 +1557,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@@ -2185,24 +1575,12 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
@@ -2215,12 +1593,6 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.33.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
diff --git a/arbitrator/wasm-libraries/Cargo.toml b/arbitrator/wasm-libraries/Cargo.toml
index 2fd585ee7d..837df8f4da 100644
--- a/arbitrator/wasm-libraries/Cargo.toml
+++ b/arbitrator/wasm-libraries/Cargo.toml
@@ -7,5 +7,6 @@ members = [
         "user-host-trait",
 	"user-test",
 	"program-exec",
+        "forward",
 ]
 resolver = "2"
diff --git a/arbitrator/wasm-libraries/forward/.gitignore b/arbitrator/wasm-libraries/forward/.gitignore
new file mode 100644
index 0000000000..40da2042b7
--- /dev/null
+++ b/arbitrator/wasm-libraries/forward/.gitignore
@@ -0,0 +1 @@
+**.wat
diff --git a/arbitrator/wasm-libraries/forward/Cargo.toml b/arbitrator/wasm-libraries/forward/Cargo.toml
new file mode 100644
index 0000000000..73ed9d8827
--- /dev/null
+++ b/arbitrator/wasm-libraries/forward/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "forward"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+eyre = "0.6.5"
+structopt = "0.3.26"
diff --git a/arbitrator/wasm-libraries/forward/src/main.rs b/arbitrator/wasm-libraries/forward/src/main.rs
new file mode 100644
index 0000000000..f978a8723b
--- /dev/null
+++ b/arbitrator/wasm-libraries/forward/src/main.rs
@@ -0,0 +1,207 @@
+// Copyright 2022-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+use eyre::Result;
+use std::{fs::File, io::Write, path::PathBuf};
+use structopt::StructOpt;
+
+/// order matters!
+const HOSTIOS: [[&str; 3]; 42] = [
+    ["read_args", "i32", ""],
+    ["write_result", "i32 i32", ""],
+    ["exit_early", "i32", ""],
+    ["storage_load_bytes32", "i32 i32", ""],
+    ["storage_cache_bytes32", "i32 i32", ""],
+    ["storage_flush_cache", "i32", ""],
+    ["transient_load_bytes32", "i32 i32", ""],
+    ["transient_store_bytes32", "i32 i32", ""],
+    ["call_contract", "i32 i32 i32 i32 i64 i32", "i32"],
+    ["delegate_call_contract", "i32 i32 i32 i64 i32", "i32"],
+    ["static_call_contract", "i32 i32 i32 i64 i32", "i32"],
+    ["create1", "i32 i32 i32 i32 i32", ""],
+    ["create2", "i32 i32 i32 i32 i32 i32", ""],
+    ["read_return_data", "i32 i32 i32", "i32"],
+    ["return_data_size", "", "i32"],
+    ["emit_log", "i32 i32 i32", ""],
+    ["account_balance", "i32 i32", ""],
+    ["account_code", "i32 i32 i32 i32", "i32"],
+    ["account_code_size", "i32", "i32"],
+    ["account_codehash", "i32 i32", ""],
+    ["evm_gas_left", "", "i64"],
+    ["evm_ink_left", "", "i64"],
+    ["block_basefee", "i32", ""],
+    ["chainid", "", "i64"],
+    ["block_coinbase", "i32", ""],
+    ["block_gas_limit", "", "i64"],
+    ["block_number", "", "i64"],
+    ["block_timestamp", "", "i64"],
+    ["contract_address", "i32", ""],
+    ["math_div", "i32 i32", ""],
+    ["math_mod", "i32 i32", ""],
+    ["math_pow", "i32 i32", ""],
+    ["math_add_mod", "i32 i32 i32", ""],
+    ["math_mul_mod", "i32 i32 i32", ""],
+    ["msg_reentrant", "", "i32"],
+    ["msg_sender", "i32", ""],
+    ["msg_value", "i32", ""],
+    ["native_keccak256", "i32 i32 i32", ""],
+    ["tx_gas_price", "i32", ""],
+    ["tx_ink_price", "", "i32"],
+    ["tx_origin", "i32", ""],
+    ["pay_for_memory_grow", "i32", ""],
+];
+
+#[derive(StructOpt)]
+#[structopt(name = "arbitrator-prover")]
+struct Opts {
+    #[structopt(long)]
+    path: PathBuf,
+    #[structopt(long)]
+    stub: bool,
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::from_args();
+    let file = &mut File::options()
+        .create(true)
+        .write(true)
+        .truncate(true)
+        .open(opts.path)?;
+
+    match opts.stub {
+        true => forward_stub(file),
+        false => forward(file),
+    }
+}
+
+fn forward(file: &mut File) -> Result<()> {
+    macro_rules! wln {
+        ($($text:tt)*) => {
+            writeln!(file, $($text)*)?;
+        };
+    }
+    let s = "    ";
+
+    wln!(
+        ";; Copyright 2022-2023, Offchain Labs, Inc.\n\
+         ;; For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE\n\
+         ;; This file is auto-generated.\n\
+         \n\
+         (module"
+    );
+
+    macro_rules! group {
+        ($list:expr, $kind:expr) => {
+            (!$list.is_empty())
+                .then(|| format!(" ({} {})", $kind, $list))
+                .unwrap_or_default()
+        };
+    }
+
+    wln!("{s};; symbols to re-export");
+    for [name, ins, outs] in HOSTIOS {
+        let params = group!(ins, "param");
+        let result = group!(outs, "result");
+        wln!(
+            r#"{s}(import "user_host" "arbitrator_forward__{name}" (func ${name}{params}{result}))"#
+        );
+    }
+    wln!();
+
+    wln!("{s};; reserved offsets for future user_host imports");
+    for i in HOSTIOS.len()..512 {
+        wln!("{s}(func $reserved_{i} unreachable)");
+    }
+    wln!();
+
+    wln!(
+        "{s};; allows user_host to request a trap\n\
+        {s}(global $trap (mut i32) (i32.const 0))\n\
+        {s}(func $check\n\
+        {s}{s}global.get $trap                    ;; see if set\n\
+        {s}{s}(global.set $trap (i32.const 0))    ;; reset the flag\n\
+        {s}{s}(if (then (unreachable)))\n\
+        {s})\n\
+        {s}(func (export \"forward__set_trap\")\n\
+        {s}{s}(global.set $trap (i32.const 1))\n\
+        {s})\n"
+    );
+
+    wln!("{s};; user linkage");
+    for [name, ins, outs] in HOSTIOS {
+        let params = group!(ins, "param");
+        let result = group!(outs, "result");
+        wln!("{s}(func (export \"vm_hooks__{name}\"){params}{result}");
+
+        let gets = (1 + ins.len()) / 4;
+        for i in 0..gets {
+            wln!("{s}{s}local.get {i}");
+        }
+
+        wln!(
+            "{s}{s}call ${name}\n\
+             {s}{s}call $check\n\
+             {s})"
+        );
+    }
+
+    wln!(")");
+    Ok(())
+}
+
+fn forward_stub(file: &mut File) -> Result<()> {
+    macro_rules! wln {
+        ($($text:tt)*) => {
+            writeln!(file, $($text)*)?;
+        };
+    }
+    let s = "    ";
+
+    wln!(
+        ";; Copyright 2022-2023, Offchain Labs, Inc.\n\
+         ;; For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE\n\
+         ;; This file is auto-generated.\n\
+         \n\
+         (module"
+    );
+
+    macro_rules! group {
+        ($list:expr, $kind:expr) => {
+            (!$list.is_empty())
+                .then(|| format!(" ({} {})", $kind, $list))
+                .unwrap_or_default()
+        };
+    }
+
+    wln!("{s};; stubs for the symbols we re-export");
+    for [name, ins, outs] in HOSTIOS {
+        let params = group!(ins, "param");
+        let result = group!(outs, "result");
+        wln!("{s}(func ${name}{params}{result} unreachable)");
+    }
+    wln!();
+
+    wln!("{s};; reserved offsets for future user_host imports");
+    for i in HOSTIOS.len()..512 {
+        wln!("{s}(func $reserved_{i} unreachable)");
+    }
+    wln!();
+
+    wln!(
+        "{s};; allows user_host to request a trap\n\
+        {s}(global $trap (mut i32) (i32.const 0))\n\
+        {s}(func $check unreachable)\n\
+        {s};; stub for the forward__set_trap function\n\
+        {s}(func $forward__set_trap unreachable)"
+    );
+
+    wln!("{s};; user linkage");
+    for [name, ins, outs] in HOSTIOS {
+        let params = group!(ins, "param");
+        let result = group!(outs, "result");
+        wln!("{s}(func (export \"vm_hooks__{name}\"){params}{result} unreachable)");
+    }
+
+    wln!(")");
+    Ok(())
+}
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/arbitrator/wasm-testsuite/src/main.rs b/arbitrator/wasm-testsuite/src/main.rs
index cb861e3a35..2144dcf992 100644
--- a/arbitrator/wasm-testsuite/src/main.rs
+++ b/arbitrator/wasm-testsuite/src/main.rs
@@ -343,7 +343,6 @@ fn main() -> eyre::Result<()> {
                     GlobalState::default(),
                     HashMap::default(),
                     machine::get_empty_preimage_resolver(),
-                    false,
                 );
 
                 if let Err(error) = &mech {
@@ -430,7 +429,6 @@ fn main() -> eyre::Result<()> {
                     GlobalState::default(),
                     HashMap::default(),
                     machine::get_empty_preimage_resolver(),
-                    false,
                 )
                 .expect_err(&format!("failed to reject invalid module {}", filename));
             }
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/programs/native.go b/arbos/programs/native.go
index e834888b47..b13cfef2cf 100644
--- a/arbos/programs/native.go
+++ b/arbos/programs/native.go
@@ -51,11 +51,12 @@ func activateProgram(
 	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 +70,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 +83,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 +103,7 @@ func activateProgramInternal(
 		}
 		return nil, nil, err
 	}
+	hash := moduleHash.toHash()
 	targets := db.Database().WasmTargets()
 	type result struct {
 		target ethdb.WasmTarget
@@ -116,7 +120,7 @@ func activateProgramInternal(
 				output := &rustBytes{}
 				status_asm := C.stylus_compile(
 					goSlice(wasm),
-					u16(version),
+					u16(stylusVersion),
 					cbool(debug),
 					goSlice([]byte(target)),
 					output,
@@ -140,10 +144,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 +179,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)
@@ -391,6 +405,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/programs.go b/arbos/programs/programs.go
index 12102bac84..80fc139a9d 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
 	}
@@ -222,6 +222,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 +518,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/wasm.go b/arbos/programs/wasm.go
index f7191dca8f..8f79944fbe 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[:]),
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/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/nitro/init.go b/cmd/nitro/init.go
index fc59f2d231..07c74cb802 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 a13a92fdc1..1078f44808 100644
--- a/cmd/nitro/nitro.go
+++ b/cmd/nitro/nitro.go
@@ -472,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() })
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/execution/gethexec/executionengine.go b/execution/gethexec/executionengine.go
index 8594d5867d..8d6484e3c9 100644
--- a/execution/gethexec/executionengine.go
+++ b/execution/gethexec/executionengine.go
@@ -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
@@ -186,7 +186,7 @@ func (s *ExecutionEngine) Initialize(rustCacheSize uint32, targetConfig *StylusT
 	if rustCacheSize != 0 {
 		programs.ResizeWasmLruCache(rustCacheSize)
 	}
-	if err := populateStylusTargetCache(targetConfig); err != nil {
+	if err := PopulateStylusTargetCache(targetConfig); err != nil {
 		return fmt.Errorf("error populating stylus target cache: %w", err)
 	}
 	return nil
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 9ca65b8610..17cd001675 160000
--- a/go-ethereum
+++ b/go-ethereum
@@ -1 +1 @@
-Subproject commit 9ca65b86101b4c87df188923d6eeff4db992520f
+Subproject commit 17cd00167543a5a2b0b083e32820051100154c2f
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/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/validator/server_arb/machine.go b/validator/server_arb/machine.go
index e77e071d70..adca9695e2 100644
--- a/validator/server_arb/machine.go
+++ b/validator/server_arb/machine.go
@@ -92,7 +92,7 @@ func LoadSimpleMachine(wasm string, libraries []string, debugChain bool) (*Arbit
 	cWasm := C.CString(wasm)
 	cLibraries := CreateCStringList(libraries)
 	debug := usize(arbmath.BoolToUint32(debugChain))
-	mach := C.arbitrator_load_machine(cWasm, cLibraries, C.long(len(libraries)), debug, false)
+	mach := C.arbitrator_load_machine(cWasm, cLibraries, C.long(len(libraries)), debug)
 	C.free(unsafe.Pointer(cWasm))
 	FreeCStringList(cLibraries, len(libraries))
 	if mach == nil {