diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a944f08f40..8ed49634ad 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -169,6 +169,26 @@ jobs:
         run: |
           echo "Running redis tests" >> full.log
           TEST_REDIS=redis://localhost:6379/0 gotestsum --format short-verbose -- -p 1 -run TestRedis ./arbnode/... ./system_tests/... -coverprofile=coverage-redis.txt -covermode=atomic -coverpkg=./...
+      
+      - name: create block input json file
+        if: matrix.test-mode == 'defaults'
+        run: |
+          gotestsum --format short-verbose -- -run TestProgramStorage$ ./system_tests/... --count 1 --recordBlockInputs.WithBaseDir="${{ github.workspace }}/target" --recordBlockInputs.WithTimestampDirEnabled=false --recordBlockInputs.WithBlockIdInFileNameEnabled=false
+      
+      - name: run arbitrator prover on block input json
+        if: matrix.test-mode == 'defaults'
+        run: |
+          make build-prover-bin
+          target/bin/prover target/machines/latest/machine.wavm.br -b --json-inputs="${{ github.workspace }}/target/TestProgramStorage/block_inputs.json"
+      
+      - name: run jit prover on block input json
+        if: matrix.test-mode == 'defaults'
+        run: |
+          make build-jit
+          if [ -n "$(target/bin/jit --binary target/machines/latest/replay.wasm --cranelift --json-inputs='${{ github.workspace }}/target/TestProgramStorage/block_inputs.json')" ]; then
+            echo "Error: Command produced output."
+            exit 1
+          fi
 
       - name: run challenge tests
         if: matrix.test-mode == 'challenge'
diff --git a/arbitrator/arbutil/src/evm/api.rs b/arbitrator/arbutil/src/evm/api.rs
index 9d4c78c0de..0a603a3bb2 100644
--- a/arbitrator/arbutil/src/evm/api.rs
+++ b/arbitrator/arbutil/src/evm/api.rs
@@ -73,19 +73,103 @@ impl DataReader for VecReader {
     }
 }
 
+macro_rules! derive_math {
+    ($t:ident) => {
+        impl std::ops::Add for $t {
+            type Output = Self;
+
+            fn add(self, rhs: Self) -> Self {
+                Self(self.0 + rhs.0)
+            }
+        }
+
+        impl std::ops::AddAssign for $t {
+            fn add_assign(&mut self, rhs: Self) {
+                self.0 += rhs.0;
+            }
+        }
+
+        impl std::ops::Sub for $t {
+            type Output = Self;
+
+            fn sub(self, rhs: Self) -> Self {
+                Self(self.0 - rhs.0)
+            }
+        }
+
+        impl std::ops::SubAssign for $t {
+            fn sub_assign(&mut self, rhs: Self) {
+                self.0 -= rhs.0;
+            }
+        }
+
+        impl std::ops::Mul<u64> for $t {
+            type Output = Self;
+
+            fn mul(self, rhs: u64) -> Self {
+                Self(self.0 * rhs)
+            }
+        }
+
+        impl std::ops::Mul<$t> for u64 {
+            type Output = $t;
+
+            fn mul(self, rhs: $t) -> $t {
+                $t(self * rhs.0)
+            }
+        }
+
+        impl $t {
+            /// Equivalent to the Add trait, but const.
+            pub const fn add(self, rhs: Self) -> Self {
+                Self(self.0 + rhs.0)
+            }
+
+            /// Equivalent to the Sub trait, but const.
+            pub const fn sub(self, rhs: Self) -> Self {
+                Self(self.0 - rhs.0)
+            }
+
+            pub const fn saturating_add(self, rhs: Self) -> Self {
+                Self(self.0.saturating_add(rhs.0))
+            }
+
+            pub const fn saturating_sub(self, rhs: Self) -> Self {
+                Self(self.0.saturating_sub(rhs.0))
+            }
+
+            pub fn to_be_bytes(self) -> [u8; 8] {
+                self.0.to_be_bytes()
+            }
+        }
+    };
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+#[must_use]
+pub struct Gas(pub u64);
+
+derive_math!(Gas);
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+#[must_use]
+pub struct Ink(pub u64);
+
+derive_math!(Ink);
+
 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, evm_api_gas_to_use: u64) -> (Bytes32, u64);
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: Gas) -> (Bytes32, Gas);
 
     /// 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`.
-    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> u64;
+    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> Gas;
 
     /// Persists any dirty values in the storage cache to the EVM state trie, dropping the cache entirely if requested.
     /// Analogous to repeated invocations of `vm.SSTORE`.
-    fn flush_storage_cache(&mut self, clear: bool, gas_left: u64) -> Result<u64>;
+    fn flush_storage_cache(&mut self, clear: bool, gas_left: Gas) -> Result<Gas>;
 
     /// Reads the 32-byte value in the EVM's transient state trie at offset `key`.
     /// Analogous to `vm.TLOAD`.
@@ -102,10 +186,10 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         &mut self,
         contract: Bytes20,
         calldata: &[u8],
-        gas_left: u64,
-        gas_req: u64,
+        gas_left: Gas,
+        gas_req: Gas,
         value: Bytes32,
-    ) -> (u32, u64, UserOutcomeKind);
+    ) -> (u32, Gas, UserOutcomeKind);
 
     /// Delegate-calls the contract at the given address.
     /// Returns the EVM return data's length, the gas cost, and whether the call succeeded.
@@ -114,9 +198,9 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         &mut self,
         contract: Bytes20,
         calldata: &[u8],
-        gas_left: u64,
-        gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind);
+        gas_left: Gas,
+        gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind);
 
     /// Static-calls the contract at the given address.
     /// Returns the EVM return data's length, the gas cost, and whether the call succeeded.
@@ -125,9 +209,9 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         &mut self,
         contract: Bytes20,
         calldata: &[u8],
-        gas_left: u64,
-        gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind);
+        gas_left: Gas,
+        gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind);
 
     /// Deploys a new contract using the init code provided.
     /// Returns the new contract's address on success, or the error reason on failure.
@@ -137,8 +221,8 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         &mut self,
         code: Vec<u8>,
         endowment: Bytes32,
-        gas: u64,
-    ) -> (eyre::Result<Bytes20>, u32, u64);
+        gas: Gas,
+    ) -> (eyre::Result<Bytes20>, u32, Gas);
 
     /// Deploys a new contract using the init code provided, with an address determined in part by the `salt`.
     /// Returns the new contract's address on success, or the error reason on failure.
@@ -149,8 +233,8 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         code: Vec<u8>,
         endowment: Bytes32,
         salt: Bytes32,
-        gas: u64,
-    ) -> (eyre::Result<Bytes20>, u32, u64);
+        gas: Gas,
+    ) -> (eyre::Result<Bytes20>, u32, Gas);
 
     /// Returns the EVM return data.
     /// Analogous to `vm.RETURNDATACOPY`.
@@ -164,21 +248,21 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
     /// Gets the balance of the given account.
     /// Returns the balance and the access cost in gas.
     /// Analogous to `vm.BALANCE`.
-    fn account_balance(&mut self, address: Bytes20) -> (Bytes32, u64);
+    fn account_balance(&mut self, address: Bytes20) -> (Bytes32, Gas);
 
     /// Returns the code and the access cost in gas.
     /// Analogous to `vm.EXTCODECOPY`.
-    fn account_code(&mut self, address: Bytes20, gas_left: u64) -> (D, u64);
+    fn account_code(&mut self, address: Bytes20, gas_left: Gas) -> (D, Gas);
 
     /// Gets the hash of the given address's code.
     /// Returns the hash and the access cost in gas.
     /// Analogous to `vm.EXTCODEHASH`.
-    fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, u64);
+    fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, Gas);
 
     /// Determines the cost in gas of allocating additional wasm pages.
     /// Note: has the side effect of updating Geth's memory usage tracker.
     /// Not analogous to any EVM opcode.
-    fn add_pages(&mut self, pages: u16) -> u64;
+    fn add_pages(&mut self, pages: u16) -> Gas;
 
     /// Captures tracing information for hostio invocations during native execution.
     fn capture_hostio(
@@ -186,7 +270,7 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
         name: &str,
         args: &[u8],
         outs: &[u8],
-        start_ink: u64,
-        end_ink: u64,
+        start_ink: Ink,
+        end_ink: Ink,
     );
 }
diff --git a/arbitrator/arbutil/src/evm/mod.rs b/arbitrator/arbutil/src/evm/mod.rs
index 36dadd906a..063194b0c6 100644
--- a/arbitrator/arbutil/src/evm/mod.rs
+++ b/arbitrator/arbutil/src/evm/mod.rs
@@ -2,6 +2,7 @@
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
 use crate::{Bytes20, Bytes32};
+use api::Gas;
 
 pub mod api;
 pub mod req;
@@ -9,70 +10,70 @@ pub mod storage;
 pub mod user;
 
 // params.SstoreSentryGasEIP2200
-pub const SSTORE_SENTRY_GAS: u64 = 2300;
+pub const SSTORE_SENTRY_GAS: Gas = Gas(2300);
 
 // params.ColdAccountAccessCostEIP2929
-pub const COLD_ACCOUNT_GAS: u64 = 2600;
+pub const COLD_ACCOUNT_GAS: Gas = Gas(2600);
 
 // params.ColdSloadCostEIP2929
-pub const COLD_SLOAD_GAS: u64 = 2100;
+pub const COLD_SLOAD_GAS: Gas = Gas(2100);
 
 // params.WarmStorageReadCostEIP2929
-pub const WARM_SLOAD_GAS: u64 = 100;
+pub const WARM_SLOAD_GAS: Gas = Gas(100);
 
 // params.WarmStorageReadCostEIP2929 (see enable1153 in jump_table.go)
-pub const TLOAD_GAS: u64 = WARM_SLOAD_GAS;
-pub const TSTORE_GAS: u64 = WARM_SLOAD_GAS;
+pub const TLOAD_GAS: Gas = WARM_SLOAD_GAS;
+pub const TSTORE_GAS: Gas = WARM_SLOAD_GAS;
 
 // params.LogGas and params.LogDataGas
-pub const LOG_TOPIC_GAS: u64 = 375;
-pub const LOG_DATA_GAS: u64 = 8;
+pub const LOG_TOPIC_GAS: Gas = Gas(375);
+pub const LOG_DATA_GAS: Gas = Gas(8);
 
 // params.CopyGas
-pub const COPY_WORD_GAS: u64 = 3;
+pub const COPY_WORD_GAS: Gas = Gas(3);
 
 // params.Keccak256Gas
-pub const KECCAK_256_GAS: u64 = 30;
-pub const KECCAK_WORD_GAS: u64 = 6;
+pub const KECCAK_256_GAS: Gas = Gas(30);
+pub const KECCAK_WORD_GAS: Gas = Gas(6);
 
 // vm.GasQuickStep (see gas.go)
-pub const GAS_QUICK_STEP: u64 = 2;
+pub const GAS_QUICK_STEP: Gas = Gas(2);
 
 // vm.GasQuickStep (see jump_table.go)
-pub const ADDRESS_GAS: u64 = GAS_QUICK_STEP;
+pub const ADDRESS_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see eips.go)
-pub const BASEFEE_GAS: u64 = GAS_QUICK_STEP;
+pub const BASEFEE_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see eips.go)
-pub const CHAINID_GAS: u64 = GAS_QUICK_STEP;
+pub const CHAINID_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const COINBASE_GAS: u64 = GAS_QUICK_STEP;
+pub const COINBASE_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const GASLIMIT_GAS: u64 = GAS_QUICK_STEP;
+pub const GASLIMIT_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const NUMBER_GAS: u64 = GAS_QUICK_STEP;
+pub const NUMBER_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const TIMESTAMP_GAS: u64 = GAS_QUICK_STEP;
+pub const TIMESTAMP_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const GASLEFT_GAS: u64 = GAS_QUICK_STEP;
+pub const GASLEFT_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const CALLER_GAS: u64 = GAS_QUICK_STEP;
+pub const CALLER_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const CALLVALUE_GAS: u64 = GAS_QUICK_STEP;
+pub const CALLVALUE_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const GASPRICE_GAS: u64 = GAS_QUICK_STEP;
+pub const GASPRICE_GAS: Gas = GAS_QUICK_STEP;
 
 // vm.GasQuickStep (see jump_table.go)
-pub const ORIGIN_GAS: u64 = GAS_QUICK_STEP;
+pub const ORIGIN_GAS: Gas = GAS_QUICK_STEP;
 
 pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32;
 
diff --git a/arbitrator/arbutil/src/evm/req.rs b/arbitrator/arbutil/src/evm/req.rs
index 0304f2d378..621f41e951 100644
--- a/arbitrator/arbutil/src/evm/req.rs
+++ b/arbitrator/arbutil/src/evm/req.rs
@@ -12,8 +12,10 @@ use crate::{
 use eyre::{bail, eyre, Result};
 use std::collections::hash_map::Entry;
 
+use super::api::{Gas, Ink};
+
 pub trait RequestHandler<D: DataReader>: Send + 'static {
-    fn request(&mut self, req_type: EvmApiMethod, req_data: impl AsRef<[u8]>) -> (Vec<u8>, D, u64);
+    fn request(&mut self, req_type: EvmApiMethod, req_data: impl AsRef<[u8]>) -> (Vec<u8>, D, Gas);
 }
 
 pub struct EvmApiRequestor<D: DataReader, H: RequestHandler<D>> {
@@ -33,7 +35,7 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApiRequestor<D, H> {
         }
     }
 
-    fn request(&mut self, req_type: EvmApiMethod, req_data: impl AsRef<[u8]>) -> (Vec<u8>, D, u64) {
+    fn request(&mut self, req_type: EvmApiMethod, req_data: impl AsRef<[u8]>) -> (Vec<u8>, D, Gas) {
         self.handler.request(req_type, req_data)
     }
 
@@ -43,10 +45,10 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApiRequestor<D, H> {
         call_type: EvmApiMethod,
         contract: Bytes20,
         input: &[u8],
-        gas_left: u64,
-        gas_req: u64,
+        gas_left: Gas,
+        gas_req: Gas,
         value: Bytes32,
-    ) -> (u32, u64, UserOutcomeKind) {
+    ) -> (u32, Gas, UserOutcomeKind) {
         let mut request = Vec::with_capacity(20 + 32 + 8 + 8 + input.len());
         request.extend(contract);
         request.extend(value);
@@ -71,8 +73,8 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApiRequestor<D, H> {
         code: Vec<u8>,
         endowment: Bytes32,
         salt: Option<Bytes32>,
-        gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         let mut request = Vec::with_capacity(8 + 2 * 32 + code.len());
         request.extend(gas.to_be_bytes());
         request.extend(endowment);
@@ -98,7 +100,7 @@ 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, evm_api_gas_to_use: u64) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: Gas) -> (Bytes32, Gas) {
         let cache = &mut self.storage_cache;
         let mut cost = cache.read_gas();
 
@@ -110,7 +112,7 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         (value.value, cost)
     }
 
-    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> u64 {
+    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> Gas {
         let cost = self.storage_cache.write_gas();
         match self.storage_cache.entry(key) {
             Entry::Occupied(mut key) => key.get_mut().value = value,
@@ -119,7 +121,7 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         cost
     }
 
-    fn flush_storage_cache(&mut self, clear: bool, gas_left: u64) -> Result<u64> {
+    fn flush_storage_cache(&mut self, clear: bool, gas_left: Gas) -> Result<Gas> {
         let mut data = Vec::with_capacity(64 * self.storage_cache.len() + 8);
         data.extend(gas_left.to_be_bytes());
 
@@ -134,7 +136,7 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
             self.storage_cache.clear();
         }
         if data.len() == 8 {
-            return Ok(0); // no need to make request
+            return Ok(Gas(0)); // no need to make request
         }
 
         let (res, _, cost) = self.request(EvmApiMethod::SetTrieSlots, data);
@@ -174,10 +176,10 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         &mut self,
         contract: Bytes20,
         input: &[u8],
-        gas_left: u64,
-        gas_req: u64,
+        gas_left: Gas,
+        gas_req: Gas,
         value: Bytes32,
-    ) -> (u32, u64, UserOutcomeKind) {
+    ) -> (u32, Gas, UserOutcomeKind) {
         self.call_request(
             EvmApiMethod::ContractCall,
             contract,
@@ -192,9 +194,9 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         &mut self,
         contract: Bytes20,
         input: &[u8],
-        gas_left: u64,
-        gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        gas_left: Gas,
+        gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         self.call_request(
             EvmApiMethod::DelegateCall,
             contract,
@@ -209,9 +211,9 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         &mut self,
         contract: Bytes20,
         input: &[u8],
-        gas_left: u64,
-        gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        gas_left: Gas,
+        gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         self.call_request(
             EvmApiMethod::StaticCall,
             contract,
@@ -226,8 +228,8 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         &mut self,
         code: Vec<u8>,
         endowment: Bytes32,
-        gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         self.create_request(EvmApiMethod::Create1, code, endowment, None, gas)
     }
 
@@ -236,8 +238,8 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         code: Vec<u8>,
         endowment: Bytes32,
         salt: Bytes32,
-        gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         self.create_request(EvmApiMethod::Create2, code, endowment, Some(salt), gas)
     }
 
@@ -258,15 +260,15 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         Ok(())
     }
 
-    fn account_balance(&mut self, address: Bytes20) -> (Bytes32, u64) {
+    fn account_balance(&mut self, address: Bytes20) -> (Bytes32, Gas) {
         let (res, _, cost) = self.request(EvmApiMethod::AccountBalance, address);
         (res.try_into().unwrap(), cost)
     }
 
-    fn account_code(&mut self, address: Bytes20, gas_left: u64) -> (D, u64) {
+    fn account_code(&mut self, address: Bytes20, gas_left: Gas) -> (D, Gas) {
         if let Some((stored_address, data)) = self.last_code.as_ref() {
             if address == *stored_address {
-                return (data.clone(), 0);
+                return (data.clone(), Gas(0));
             }
         }
         let mut req = Vec::with_capacity(20 + 8);
@@ -278,12 +280,12 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         (data, cost)
     }
 
-    fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, u64) {
+    fn account_codehash(&mut self, address: Bytes20) -> (Bytes32, Gas) {
         let (res, _, cost) = self.request(EvmApiMethod::AccountCodeHash, address);
         (res.try_into().unwrap(), cost)
     }
 
-    fn add_pages(&mut self, pages: u16) -> u64 {
+    fn add_pages(&mut self, pages: u16) -> Gas {
         self.request(EvmApiMethod::AddPages, pages.to_be_bytes()).2
     }
 
@@ -292,8 +294,8 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         name: &str,
         args: &[u8],
         outs: &[u8],
-        start_ink: u64,
-        end_ink: u64,
+        start_ink: Ink,
+        end_ink: Ink,
     ) {
         let mut request = Vec::with_capacity(2 * 8 + 3 * 2 + name.len() + args.len() + outs.len());
         request.extend(start_ink.to_be_bytes());
@@ -305,6 +307,7 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         request.extend(name.as_bytes());
         request.extend(args);
         request.extend(outs);
-        self.request(EvmApiMethod::CaptureHostIO, request);
+        // ignore response (including gas) as we're just tracing
+        _ = self.request(EvmApiMethod::CaptureHostIO, request);
     }
 }
diff --git a/arbitrator/arbutil/src/evm/storage.rs b/arbitrator/arbutil/src/evm/storage.rs
index 32b60dd21b..5f688364d7 100644
--- a/arbitrator/arbutil/src/evm/storage.rs
+++ b/arbitrator/arbutil/src/evm/storage.rs
@@ -5,6 +5,8 @@ use crate::Bytes32;
 use fnv::FnvHashMap as HashMap;
 use std::ops::{Deref, DerefMut};
 
+use super::api::Gas;
+
 /// Represents the EVM word at a given key.
 #[derive(Debug)]
 pub struct StorageWord {
@@ -37,23 +39,23 @@ pub struct StorageCache {
 }
 
 impl StorageCache {
-    pub const REQUIRED_ACCESS_GAS: u64 = 10;
+    pub const REQUIRED_ACCESS_GAS: Gas = Gas(10);
 
-    pub fn read_gas(&mut self) -> u64 {
+    pub fn read_gas(&mut self) -> Gas {
         self.reads += 1;
         match self.reads {
-            0..=32 => 0,
-            33..=128 => 2,
-            _ => 10,
+            0..=32 => Gas(0),
+            33..=128 => Gas(2),
+            _ => Gas(10),
         }
     }
 
-    pub fn write_gas(&mut self) -> u64 {
+    pub fn write_gas(&mut self) -> Gas {
         self.writes += 1;
         match self.writes {
-            0..=8 => 0,
-            9..=64 => 7,
-            _ => 10,
+            0..=8 => Gas(0),
+            9..=64 => Gas(7),
+            _ => Gas(10),
         }
     }
 }
diff --git a/arbitrator/arbutil/src/pricing.rs b/arbitrator/arbutil/src/pricing.rs
index 4614b02a2a..4d6bf827be 100644
--- a/arbitrator/arbutil/src/pricing.rs
+++ b/arbitrator/arbutil/src/pricing.rs
@@ -1,20 +1,22 @@
 // Copyright 2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
+use crate::evm::api::Ink;
+
 /// For hostios that may return something.
-pub const HOSTIO_INK: u64 = 8400;
+pub const HOSTIO_INK: Ink = Ink(8400);
 
 /// For hostios that include pointers.
-pub const PTR_INK: u64 = 13440 - HOSTIO_INK;
+pub const PTR_INK: Ink = Ink(13440).sub(HOSTIO_INK);
 
 /// For hostios that involve an API cost.
-pub const EVM_API_INK: u64 = 59673;
+pub const EVM_API_INK: Ink = Ink(59673);
 
 /// For hostios that involve a div or mod.
-pub const DIV_INK: u64 = 20000;
+pub const DIV_INK: Ink = Ink(20000);
 
 /// For hostios that involve a mulmod.
-pub const MUL_MOD_INK: u64 = 24100;
+pub const MUL_MOD_INK: Ink = Ink(24100);
 
 /// For hostios that involve an addmod.
-pub const ADD_MOD_INK: u64 = 21000;
+pub const ADD_MOD_INK: Ink = Ink(21000);
diff --git a/arbitrator/jit/src/machine.rs b/arbitrator/jit/src/machine.rs
index 02523f740a..0d74c74ef6 100644
--- a/arbitrator/jit/src/machine.rs
+++ b/arbitrator/jit/src/machine.rs
@@ -2,8 +2,8 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
 use crate::{
-    arbcompress, caller_env::GoRuntimeState, program, socket, stylus_backend::CothreadHandler,
-    wasip1_stub, wavmio, Opts,
+    arbcompress, caller_env::GoRuntimeState, prepare::prepare_env, program, socket,
+    stylus_backend::CothreadHandler, wasip1_stub, wavmio, Opts,
 };
 use arbutil::{Bytes32, Color, PreimageType};
 use eyre::{bail, ErrReport, Result, WrapErr};
@@ -215,72 +215,76 @@ pub struct WasmEnv {
 
 impl WasmEnv {
     pub fn cli(opts: &Opts) -> Result<Self> {
-        let mut env = WasmEnv::default();
-        env.process.forks = opts.forks;
-        env.process.debug = opts.debug;
+        if let Some(json_inputs) = opts.json_inputs.clone() {
+            prepare_env(json_inputs, opts.debug)
+        } else {
+            let mut env = WasmEnv::default();
+            env.process.forks = opts.forks;
+            env.process.debug = opts.debug;
 
-        let mut inbox_position = opts.inbox_position;
-        let mut delayed_position = opts.delayed_inbox_position;
+            let mut inbox_position = opts.inbox_position;
+            let mut delayed_position = opts.delayed_inbox_position;
 
-        for path in &opts.inbox {
-            let mut msg = vec![];
-            File::open(path)?.read_to_end(&mut msg)?;
-            env.sequencer_messages.insert(inbox_position, msg);
-            inbox_position += 1;
-        }
-        for path in &opts.delayed_inbox {
-            let mut msg = vec![];
-            File::open(path)?.read_to_end(&mut msg)?;
-            env.delayed_messages.insert(delayed_position, msg);
-            delayed_position += 1;
-        }
+            for path in &opts.inbox {
+                let mut msg = vec![];
+                File::open(path)?.read_to_end(&mut msg)?;
+                env.sequencer_messages.insert(inbox_position, msg);
+                inbox_position += 1;
+            }
+            for path in &opts.delayed_inbox {
+                let mut msg = vec![];
+                File::open(path)?.read_to_end(&mut msg)?;
+                env.delayed_messages.insert(delayed_position, msg);
+                delayed_position += 1;
+            }
 
-        if let Some(path) = &opts.preimages {
-            let mut file = BufReader::new(File::open(path)?);
-            let mut preimages = Vec::new();
-            let filename = path.to_string_lossy();
-            loop {
-                let mut size_buf = [0u8; 8];
-                match file.read_exact(&mut size_buf) {
-                    Ok(()) => {}
-                    Err(err) if err.kind() == ErrorKind::UnexpectedEof => break,
-                    Err(err) => bail!("Failed to parse {filename}: {}", err),
+            if let Some(path) = &opts.preimages {
+                let mut file = BufReader::new(File::open(path)?);
+                let mut preimages = Vec::new();
+                let filename = path.to_string_lossy();
+                loop {
+                    let mut size_buf = [0u8; 8];
+                    match file.read_exact(&mut size_buf) {
+                        Ok(()) => {}
+                        Err(err) if err.kind() == ErrorKind::UnexpectedEof => break,
+                        Err(err) => bail!("Failed to parse {filename}: {}", err),
+                    }
+                    let size = u64::from_le_bytes(size_buf) as usize;
+                    let mut buf = vec![0u8; size];
+                    file.read_exact(&mut buf)?;
+                    preimages.push(buf);
+                }
+                let keccak_preimages = env.preimages.entry(PreimageType::Keccak256).or_default();
+                for preimage in preimages {
+                    let mut hasher = Keccak256::new();
+                    hasher.update(&preimage);
+                    let hash = hasher.finalize().into();
+                    keccak_preimages.insert(hash, preimage);
                 }
-                let size = u64::from_le_bytes(size_buf) as usize;
-                let mut buf = vec![0u8; size];
-                file.read_exact(&mut buf)?;
-                preimages.push(buf);
-            }
-            let keccak_preimages = env.preimages.entry(PreimageType::Keccak256).or_default();
-            for preimage in preimages {
-                let mut hasher = Keccak256::new();
-                hasher.update(&preimage);
-                let hash = hasher.finalize().into();
-                keccak_preimages.insert(hash, preimage);
             }
-        }
 
-        fn parse_hex(arg: &Option<String>, name: &str) -> Result<Bytes32> {
-            match arg {
-                Some(arg) => {
-                    let mut arg = arg.as_str();
-                    if arg.starts_with("0x") {
-                        arg = &arg[2..];
+            fn parse_hex(arg: &Option<String>, name: &str) -> Result<Bytes32> {
+                match arg {
+                    Some(arg) => {
+                        let mut arg = arg.as_str();
+                        if arg.starts_with("0x") {
+                            arg = &arg[2..];
+                        }
+                        let mut bytes32 = [0u8; 32];
+                        hex::decode_to_slice(arg, &mut bytes32)
+                            .wrap_err_with(|| format!("failed to parse {} contents", name))?;
+                        Ok(bytes32.into())
                     }
-                    let mut bytes32 = [0u8; 32];
-                    hex::decode_to_slice(arg, &mut bytes32)
-                        .wrap_err_with(|| format!("failed to parse {} contents", name))?;
-                    Ok(bytes32.into())
+                    None => Ok(Bytes32::default()),
                 }
-                None => Ok(Bytes32::default()),
             }
-        }
 
-        let last_block_hash = parse_hex(&opts.last_block_hash, "--last-block-hash")?;
-        let last_send_root = parse_hex(&opts.last_send_root, "--last-send-root")?;
-        env.small_globals = [opts.inbox_position, opts.position_within_message];
-        env.large_globals = [last_block_hash, last_send_root];
-        Ok(env)
+            let last_block_hash = parse_hex(&opts.last_block_hash, "--last-block-hash")?;
+            let last_send_root = parse_hex(&opts.last_send_root, "--last-send-root")?;
+            env.small_globals = [opts.inbox_position, opts.position_within_message];
+            env.large_globals = [last_block_hash, last_send_root];
+            Ok(env)
+        }
     }
 
     pub fn send_results(&mut self, error: Option<String>, memory_used: Pages) {
diff --git a/arbitrator/jit/src/main.rs b/arbitrator/jit/src/main.rs
index e432dc215c..6e44500215 100644
--- a/arbitrator/jit/src/main.rs
+++ b/arbitrator/jit/src/main.rs
@@ -10,6 +10,7 @@ use structopt::StructOpt;
 mod arbcompress;
 mod caller_env;
 mod machine;
+mod prepare;
 mod program;
 mod socket;
 mod stylus_backend;
@@ -46,6 +47,10 @@ pub struct Opts {
     debug: bool,
     #[structopt(long)]
     require_success: bool,
+    // JSON inputs supercede any of the command-line inputs which could
+    // be specified in the JSON file.
+    #[structopt(long)]
+    json_inputs: Option<PathBuf>,
 }
 
 fn main() -> Result<()> {
diff --git a/arbitrator/jit/src/prepare.rs b/arbitrator/jit/src/prepare.rs
new file mode 100644
index 0000000000..e7a7ba0f4d
--- /dev/null
+++ b/arbitrator/jit/src/prepare.rs
@@ -0,0 +1,73 @@
+// Copyright 2022-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+
+use crate::WasmEnv;
+use arbutil::{Bytes32, PreimageType};
+use eyre::Ok;
+use prover::parse_input::FileData;
+use std::env;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::PathBuf;
+
+// local_target matches rawdb.LocalTarget() on the go side.
+// While generating json_inputs file, one should make sure user_wasms map
+// has entry for the system's arch that jit validation is being run on
+pub fn local_target() -> String {
+    if env::consts::OS == "linux" {
+        match env::consts::ARCH {
+            "aarch64" => "arm64".to_string(),
+            "x86_64" => "amd64".to_string(),
+            _ => "host".to_string(),
+        }
+    } else {
+        "host".to_string()
+    }
+}
+
+pub fn prepare_env(json_inputs: PathBuf, debug: bool) -> eyre::Result<WasmEnv> {
+    let file = File::open(json_inputs)?;
+    let reader = BufReader::new(file);
+
+    let data = FileData::from_reader(reader)?;
+
+    let mut env = WasmEnv::default();
+    env.process.forks = false; // Should be set to false when using json_inputs
+    env.process.debug = debug;
+
+    let block_hash: [u8; 32] = data.start_state.block_hash.try_into().unwrap();
+    let block_hash: Bytes32 = block_hash.into();
+    let send_root: [u8; 32] = data.start_state.send_root.try_into().unwrap();
+    let send_root: Bytes32 = send_root.into();
+    let bytes32_vals: [Bytes32; 2] = [block_hash, send_root];
+    let u64_vals: [u64; 2] = [data.start_state.batch, data.start_state.pos_in_batch];
+    env.small_globals = u64_vals;
+    env.large_globals = bytes32_vals;
+
+    for batch_info in data.batch_info.iter() {
+        env.sequencer_messages
+            .insert(batch_info.number, batch_info.data_b64.clone());
+    }
+
+    if data.delayed_msg_nr != 0 && !data.delayed_msg_b64.is_empty() {
+        env.delayed_messages
+            .insert(data.delayed_msg_nr, data.delayed_msg_b64.clone());
+    }
+
+    for (ty, inner_map) in data.preimages_b64 {
+        let preimage_ty = PreimageType::try_from(ty as u8)?;
+        let map = env.preimages.entry(preimage_ty).or_default();
+        for (hash, preimage) in inner_map {
+            map.insert(hash, preimage);
+        }
+    }
+
+    if let Some(user_wasms) = data.user_wasms.get(&local_target()) {
+        for (module_hash, module_asm) in user_wasms.iter() {
+            env.module_asms
+                .insert(*module_hash, module_asm.as_vec().into());
+        }
+    }
+
+    Ok(env)
+}
diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs
index 084afe96bc..f10a059748 100644
--- a/arbitrator/jit/src/program.rs
+++ b/arbitrator/jit/src/program.rs
@@ -6,6 +6,7 @@
 use crate::caller_env::JitEnv;
 use crate::machine::{Escape, MaybeEscape, WasmEnvMut};
 use crate::stylus_backend::exec_wasm;
+use arbutil::evm::api::Gas;
 use arbutil::Bytes32;
 use arbutil::{evm::EvmData, format::DebugBytes, heapify};
 use caller_env::{GuestPtr, MemAccess};
@@ -131,7 +132,7 @@ pub fn new_program(
 
     // buy ink
     let pricing = config.stylus.pricing;
-    let ink = pricing.gas_to_ink(gas);
+    let ink = pricing.gas_to_ink(Gas(gas));
 
     let Some(module) = exec.module_asms.get(&compiled_hash).cloned() else {
         return Err(Escape::Failure(format!(
@@ -217,7 +218,7 @@ pub fn set_response(
     let raw_data = mem.read_slice(raw_data_ptr, raw_data_len as usize);
 
     let thread = exec.threads.last_mut().unwrap();
-    thread.set_response(id, result, raw_data, gas)
+    thread.set_response(id, result, raw_data, Gas(gas))
 }
 
 /// sends previos response
diff --git a/arbitrator/jit/src/stylus_backend.rs b/arbitrator/jit/src/stylus_backend.rs
index 61dbf258d4..0d8c477c6c 100644
--- a/arbitrator/jit/src/stylus_backend.rs
+++ b/arbitrator/jit/src/stylus_backend.rs
@@ -4,7 +4,7 @@
 #![allow(clippy::too_many_arguments)]
 
 use crate::machine::{Escape, MaybeEscape};
-use arbutil::evm::api::VecReader;
+use arbutil::evm::api::{Gas, Ink, VecReader};
 use arbutil::evm::{
     api::{EvmApiMethod, EVM_API_METHOD_REQ_OFFSET},
     req::EvmApiRequestor,
@@ -28,7 +28,7 @@ use stylus::{native::NativeInstance, run::RunProgram};
 struct MessageToCothread {
     result: Vec<u8>,
     raw_data: Vec<u8>,
-    cost: u64,
+    cost: Gas,
 }
 
 #[derive(Clone)]
@@ -47,7 +47,7 @@ impl RequestHandler<VecReader> for CothreadRequestor {
         &mut self,
         req_type: EvmApiMethod,
         req_data: impl AsRef<[u8]>,
-    ) -> (Vec<u8>, VecReader, u64) {
+    ) -> (Vec<u8>, VecReader, Gas) {
         let msg = MessageFromCothread {
             req_type: req_type as u32 + EVM_API_METHOD_REQ_OFFSET,
             req_data: req_data.as_ref().to_vec(),
@@ -104,7 +104,7 @@ impl CothreadHandler {
         id: u32,
         result: Vec<u8>,
         raw_data: Vec<u8>,
-        cost: u64,
+        cost: Gas,
     ) -> MaybeEscape {
         let Some(msg) = self.last_request.clone() else {
             return Escape::hostio("trying to set response but no message pending");
@@ -131,7 +131,7 @@ pub fn exec_wasm(
     compile: CompileConfig,
     config: StylusConfig,
     evm_data: EvmData,
-    ink: u64,
+    ink: Ink,
 ) -> Result<CothreadHandler> {
     let (tothread_tx, tothread_rx) = mpsc::sync_channel::<MessageToCothread>(0);
     let (fromthread_tx, fromthread_rx) = mpsc::sync_channel::<MessageFromCothread>(0);
@@ -150,7 +150,7 @@ pub fn exec_wasm(
         let outcome = instance.run_main(&calldata, config, ink);
 
         let ink_left = match outcome.as_ref() {
-            Ok(UserOutcome::OutOfStack) => 0, // take all ink when out of stack
+            Ok(UserOutcome::OutOfStack) => Ink(0), // take all ink when out of stack
             _ => instance.ink_left().into(),
         };
 
diff --git a/arbitrator/prover/src/machine.rs b/arbitrator/prover/src/machine.rs
index 4ece1f7bf2..dec355ac7c 100644
--- a/arbitrator/prover/src/machine.rs
+++ b/arbitrator/prover/src/machine.rs
@@ -1816,7 +1816,12 @@ impl Machine {
     }
 
     #[cfg(feature = "native")]
-    pub fn call_user_func(&mut self, func: &str, args: Vec<Value>, ink: u64) -> Result<Vec<Value>> {
+    pub fn call_user_func(
+        &mut self,
+        func: &str,
+        args: Vec<Value>,
+        ink: arbutil::evm::api::Ink,
+    ) -> Result<Vec<Value>> {
         self.set_ink(ink);
         self.call_function("user", func, args)
     }
diff --git a/arbitrator/prover/src/merkle.rs b/arbitrator/prover/src/merkle.rs
index 4a1278b4cb..fbd704dfc6 100644
--- a/arbitrator/prover/src/merkle.rs
+++ b/arbitrator/prover/src/merkle.rs
@@ -549,8 +549,7 @@ mod test {
         let mut empty_node = Bytes32([
             57, 29, 211, 154, 252, 227, 18, 99, 65, 126, 203, 166, 252, 232, 32, 3, 98, 194, 254,
             186, 118, 14, 139, 192, 101, 156, 55, 194, 101, 11, 11, 168,
-        ])
-        .clone();
+        ]);
         for _ in 0..64 {
             print!("Bytes32([");
             for i in 0..32 {
@@ -607,7 +606,7 @@ mod test {
             for layer in 0..64 {
                 // empty_hash_at is just a lookup, but empty_hash is calculated iteratively.
                 assert_eq!(empty_hash_at(ty, layer), &empty_hash);
-                empty_hash = hash_node(ty, &empty_hash, &empty_hash);
+                empty_hash = hash_node(ty, empty_hash, empty_hash);
             }
         }
     }
diff --git a/arbitrator/prover/src/programs/config.rs b/arbitrator/prover/src/programs/config.rs
index 0353589358..bd6fb3a843 100644
--- a/arbitrator/prover/src/programs/config.rs
+++ b/arbitrator/prover/src/programs/config.rs
@@ -4,6 +4,7 @@
 #![allow(clippy::field_reassign_with_default)]
 
 use crate::{programs::meter, value::FunctionType};
+use arbutil::evm::api::{Gas, Ink};
 use derivative::Derivative;
 use fnv::FnvHashMap as HashMap;
 use std::fmt::Debug;
@@ -72,12 +73,12 @@ impl PricingParams {
         Self { ink_price }
     }
 
-    pub fn gas_to_ink(&self, gas: u64) -> u64 {
-        gas.saturating_mul(self.ink_price.into())
+    pub fn gas_to_ink(&self, gas: Gas) -> Ink {
+        Ink(gas.0.saturating_mul(self.ink_price.into()))
     }
 
-    pub fn ink_to_gas(&self, ink: u64) -> u64 {
-        ink / self.ink_price as u64 // never 0
+    pub fn ink_to_gas(&self, ink: Ink) -> Gas {
+        Gas(ink.0 / self.ink_price as u64) // ink_price is never 0
     }
 }
 
diff --git a/arbitrator/prover/src/programs/memory.rs b/arbitrator/prover/src/programs/memory.rs
index 7253b59dc4..82c4d4469d 100644
--- a/arbitrator/prover/src/programs/memory.rs
+++ b/arbitrator/prover/src/programs/memory.rs
@@ -1,6 +1,8 @@
 // Copyright 2023, Offchain Labs, Inc.
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
+use arbutil::evm::api::Gas;
+
 #[derive(Clone, Copy, Debug)]
 #[repr(C)]
 pub struct MemoryModel {
@@ -28,20 +30,20 @@ impl MemoryModel {
     }
 
     /// Determines the gas cost of allocating `new` pages given `open` are active and `ever` have ever been.
-    pub fn gas_cost(&self, new: u16, open: u16, ever: u16) -> u64 {
+    pub fn gas_cost(&self, new: u16, open: u16, ever: u16) -> Gas {
         let new_open = open.saturating_add(new);
         let new_ever = ever.max(new_open);
 
         // free until expansion beyond the first few
         if new_ever <= self.free_pages {
-            return 0;
+            return Gas(0);
         }
 
         let credit = |pages: u16| pages.saturating_sub(self.free_pages);
         let adding = credit(new_open).saturating_sub(credit(open)) as u64;
         let linear = adding.saturating_mul(self.page_gas.into());
         let expand = Self::exp(new_ever) - Self::exp(ever);
-        linear.saturating_add(expand)
+        Gas(linear.saturating_add(expand))
     }
 
     fn exp(pages: u16) -> u64 {
@@ -81,14 +83,14 @@ fn test_model() {
     let model = MemoryModel::new(2, 1000);
 
     for jump in 1..=128 {
-        let mut total = 0;
+        let mut total = Gas(0);
         let mut pages = 0;
         while pages < 128 {
             let jump = jump.min(128 - pages);
             total += model.gas_cost(jump, pages, pages);
             pages += jump;
         }
-        assert_eq!(total, 31999998);
+        assert_eq!(total, Gas(31999998));
     }
 
     for jump in 1..=128 {
@@ -98,7 +100,7 @@ fn test_model() {
         let mut adds = 0;
         while ever < 128 {
             let jump = jump.min(128 - open);
-            total += model.gas_cost(jump, open, ever);
+            total += model.gas_cost(jump, open, ever).0;
             open += jump;
             ever = ever.max(open);
 
@@ -114,12 +116,12 @@ fn test_model() {
     }
 
     // check saturation
-    assert_eq!(u64::MAX, model.gas_cost(129, 0, 0));
-    assert_eq!(u64::MAX, model.gas_cost(u16::MAX, 0, 0));
+    assert_eq!(Gas(u64::MAX), model.gas_cost(129, 0, 0));
+    assert_eq!(Gas(u64::MAX), model.gas_cost(u16::MAX, 0, 0));
 
     // check free pages
     let model = MemoryModel::new(128, 1000);
-    assert_eq!(0, model.gas_cost(128, 0, 0));
-    assert_eq!(0, model.gas_cost(128, 0, 128));
-    assert_eq!(u64::MAX, model.gas_cost(129, 0, 0));
+    assert_eq!(Gas(0), model.gas_cost(128, 0, 0));
+    assert_eq!(Gas(0), model.gas_cost(128, 0, 128));
+    assert_eq!(Gas(u64::MAX), model.gas_cost(129, 0, 0));
 }
diff --git a/arbitrator/prover/src/programs/meter.rs b/arbitrator/prover/src/programs/meter.rs
index ab069fd911..0d7b3151d7 100644
--- a/arbitrator/prover/src/programs/meter.rs
+++ b/arbitrator/prover/src/programs/meter.rs
@@ -9,7 +9,14 @@ use crate::{
     value::FunctionType,
     Machine,
 };
-use arbutil::{evm, operator::OperatorInfo, Bytes32};
+use arbutil::{
+    evm::{
+        self,
+        api::{Gas, Ink},
+    },
+    operator::OperatorInfo,
+    Bytes32,
+};
 use derivative::Derivative;
 use eyre::Result;
 use fnv::FnvHashMap as HashMap;
@@ -188,15 +195,15 @@ impl<'a, F: OpcodePricer> FuncMiddleware<'a> for FuncMeter<'a, F> {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum MachineMeter {
-    Ready(u64),
+    Ready(Ink),
     Exhausted,
 }
 
 impl MachineMeter {
-    pub fn ink(self) -> u64 {
+    pub fn ink(self) -> Ink {
         match self {
             Self::Ready(ink) => ink,
-            Self::Exhausted => 0,
+            Self::Exhausted => Ink(0),
         }
     }
 
@@ -210,8 +217,8 @@ impl MachineMeter {
 
 /// We don't implement `From` since it's unclear what 0 would map to
 #[allow(clippy::from_over_into)]
-impl Into<u64> for MachineMeter {
-    fn into(self) -> u64 {
+impl Into<Ink> for MachineMeter {
+    fn into(self) -> Ink {
         self.ink()
     }
 }
@@ -219,7 +226,7 @@ impl Into<u64> for MachineMeter {
 impl Display for MachineMeter {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Ready(ink) => write!(f, "{ink} ink"),
+            Self::Ready(ink) => write!(f, "{} ink", ink.0),
             Self::Exhausted => write!(f, "exhausted"),
         }
     }
@@ -241,7 +248,7 @@ pub trait MeteredMachine {
     fn ink_left(&self) -> MachineMeter;
     fn set_meter(&mut self, meter: MachineMeter);
 
-    fn set_ink(&mut self, ink: u64) {
+    fn set_ink(&mut self, ink: Ink) {
         self.set_meter(MachineMeter::Ready(ink));
     }
 
@@ -250,14 +257,14 @@ pub trait MeteredMachine {
         Err(OutOfInkError)
     }
 
-    fn ink_ready(&mut self) -> Result<u64, OutOfInkError> {
+    fn ink_ready(&mut self) -> Result<Ink, OutOfInkError> {
         let MachineMeter::Ready(ink_left) = self.ink_left() else {
             return self.out_of_ink();
         };
         Ok(ink_left)
     }
 
-    fn buy_ink(&mut self, ink: u64) -> Result<(), OutOfInkError> {
+    fn buy_ink(&mut self, ink: Ink) -> Result<(), OutOfInkError> {
         let ink_left = self.ink_ready()?;
         if ink_left < ink {
             return self.out_of_ink();
@@ -267,7 +274,7 @@ pub trait MeteredMachine {
     }
 
     /// Checks if the user has enough ink, but doesn't burn any
-    fn require_ink(&mut self, ink: u64) -> Result<(), OutOfInkError> {
+    fn require_ink(&mut self, ink: Ink) -> Result<(), OutOfInkError> {
         let ink_left = self.ink_ready()?;
         if ink_left < ink {
             return self.out_of_ink();
@@ -277,18 +284,18 @@ pub trait MeteredMachine {
 
     /// Pays for a write into the client.
     fn pay_for_write(&mut self, bytes: u32) -> Result<(), OutOfInkError> {
-        self.buy_ink(sat_add_mul(5040, 30, bytes.saturating_sub(32)))
+        self.buy_ink(Ink(sat_add_mul(5040, 30, bytes.saturating_sub(32))))
     }
 
     /// Pays for a read into the host.
     fn pay_for_read(&mut self, bytes: u32) -> Result<(), OutOfInkError> {
-        self.buy_ink(sat_add_mul(16381, 55, bytes.saturating_sub(32)))
+        self.buy_ink(Ink(sat_add_mul(16381, 55, bytes.saturating_sub(32))))
     }
 
     /// Pays for both I/O and keccak.
     fn pay_for_keccak(&mut self, bytes: u32) -> Result<(), OutOfInkError> {
         let words = evm::evm_words(bytes).saturating_sub(2);
-        self.buy_ink(sat_add_mul(121800, 21000, words))
+        self.buy_ink(Ink(sat_add_mul(121800, 21000, words)))
     }
 
     /// Pays for copying bytes from geth.
@@ -305,14 +312,14 @@ pub trait MeteredMachine {
                 false => break,
             }
         }
-        self.buy_ink(3000 + exp * 17500)
+        self.buy_ink(Ink(3000 + exp * 17500))
     }
 }
 
 pub trait GasMeteredMachine: MeteredMachine {
     fn pricing(&self) -> PricingParams;
 
-    fn gas_left(&self) -> Result<u64, OutOfInkError> {
+    fn gas_left(&self) -> Result<Gas, OutOfInkError> {
         let pricing = self.pricing();
         match self.ink_left() {
             MachineMeter::Ready(ink) => Ok(pricing.ink_to_gas(ink)),
@@ -320,13 +327,13 @@ pub trait GasMeteredMachine: MeteredMachine {
         }
     }
 
-    fn buy_gas(&mut self, gas: u64) -> Result<(), OutOfInkError> {
+    fn buy_gas(&mut self, gas: Gas) -> Result<(), OutOfInkError> {
         let pricing = self.pricing();
         self.buy_ink(pricing.gas_to_ink(gas))
     }
 
     /// Checks if the user has enough gas, but doesn't burn any
-    fn require_gas(&mut self, gas: u64) -> Result<(), OutOfInkError> {
+    fn require_gas(&mut self, gas: Gas) -> Result<(), OutOfInkError> {
         let pricing = self.pricing();
         self.require_ink(pricing.gas_to_ink(gas))
     }
@@ -350,7 +357,7 @@ impl MeteredMachine for Machine {
             }};
         }
 
-        let ink = || convert!(self.get_global(STYLUS_INK_LEFT));
+        let ink = || Ink(convert!(self.get_global(STYLUS_INK_LEFT)));
         let status: u32 = convert!(self.get_global(STYLUS_INK_STATUS));
 
         match status {
@@ -362,7 +369,7 @@ impl MeteredMachine for Machine {
     fn set_meter(&mut self, meter: MachineMeter) {
         let ink = meter.ink();
         let status = meter.status();
-        self.set_global(STYLUS_INK_LEFT, ink.into()).unwrap();
+        self.set_global(STYLUS_INK_LEFT, ink.0.into()).unwrap();
         self.set_global(STYLUS_INK_STATUS, status.into()).unwrap();
     }
 }
diff --git a/arbitrator/prover/src/test.rs b/arbitrator/prover/src/test.rs
index 97170441ff..4fd739342e 100644
--- a/arbitrator/prover/src/test.rs
+++ b/arbitrator/prover/src/test.rs
@@ -1,8 +1,6 @@
 // Copyright 2022-2024, Offchain Labs, Inc.
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
-#![cfg(test)]
-
 use crate::binary;
 use brotli::Dictionary;
 use eyre::Result;
@@ -64,7 +62,7 @@ pub fn test_compress() -> Result<()> {
         let deflate = brotli::compress(data, 11, 22, dict).unwrap();
         let inflate = brotli::decompress(&deflate, dict).unwrap();
         assert_eq!(hex::encode(inflate), hex::encode(data));
-        assert!(&deflate != &last);
+        assert!(deflate != last);
         last = deflate;
     }
     Ok(())
diff --git a/arbitrator/stylus/src/env.rs b/arbitrator/stylus/src/env.rs
index 69d542070d..a153fb5bf1 100644
--- a/arbitrator/stylus/src/env.rs
+++ b/arbitrator/stylus/src/env.rs
@@ -3,7 +3,7 @@
 
 use arbutil::{
     evm::{
-        api::{DataReader, EvmApi},
+        api::{DataReader, EvmApi, Ink},
         EvmData,
     },
     pricing,
@@ -74,7 +74,7 @@ impl<D: DataReader, E: EvmApi<D>> WasmEnv<D, E> {
 
     pub fn start<'a>(
         env: &'a mut WasmEnvMut<'_, D, E>,
-        ink: u64,
+        ink: Ink,
     ) -> Result<HostioInfo<'a, D, E>, Escape> {
         let mut info = Self::program(env)?;
         info.buy_ink(pricing::HOSTIO_INK + ink)?;
@@ -88,7 +88,7 @@ impl<D: DataReader, E: EvmApi<D>> WasmEnv<D, E> {
             env,
             memory,
             store,
-            start_ink: 0,
+            start_ink: Ink(0),
         };
         if info.env.evm_data.tracing {
             info.start_ink = info.ink_ready()?;
@@ -114,16 +114,16 @@ pub struct MeterData {
 }
 
 impl MeterData {
-    pub fn ink(&self) -> u64 {
-        unsafe { self.ink_left.as_ref().val.u64 }
+    pub fn ink(&self) -> Ink {
+        Ink(unsafe { self.ink_left.as_ref().val.u64 })
     }
 
     pub fn status(&self) -> u32 {
         unsafe { self.ink_status.as_ref().val.u32 }
     }
 
-    pub fn set_ink(&mut self, ink: u64) {
-        unsafe { self.ink_left.as_mut().val = RawValue { u64: ink } }
+    pub fn set_ink(&mut self, ink: Ink) {
+        unsafe { self.ink_left.as_mut().val = RawValue { u64: ink.0 } }
     }
 
     pub fn set_status(&mut self, status: u32) {
@@ -140,7 +140,7 @@ pub struct HostioInfo<'a, D: DataReader, E: EvmApi<D>> {
     pub env: &'a mut WasmEnv<D, E>,
     pub memory: Memory,
     pub store: StoreMut<'a>,
-    pub start_ink: u64,
+    pub start_ink: Ink,
 }
 
 impl<'a, D: DataReader, E: EvmApi<D>> HostioInfo<'a, D, E> {
diff --git a/arbitrator/stylus/src/evm_api.rs b/arbitrator/stylus/src/evm_api.rs
index d267372827..0dd27e3f8c 100644
--- a/arbitrator/stylus/src/evm_api.rs
+++ b/arbitrator/stylus/src/evm_api.rs
@@ -3,7 +3,7 @@
 
 use crate::{GoSliceData, RustSlice};
 use arbutil::evm::{
-    api::{EvmApiMethod, EVM_API_METHOD_REQ_OFFSET},
+    api::{EvmApiMethod, Gas, EVM_API_METHOD_REQ_OFFSET},
     req::RequestHandler,
 };
 
@@ -31,7 +31,7 @@ impl RequestHandler<GoSliceData> for NativeRequestHandler {
         &mut self,
         req_type: EvmApiMethod,
         req_data: impl AsRef<[u8]>,
-    ) -> (Vec<u8>, GoSliceData, u64) {
+    ) -> (Vec<u8>, GoSliceData, Gas) {
         let mut result = GoSliceData::null();
         let mut raw_data = GoSliceData::null();
         let mut cost = 0;
@@ -45,6 +45,6 @@ impl RequestHandler<GoSliceData> for NativeRequestHandler {
                 ptr!(raw_data),
             )
         };
-        (result.slice().to_vec(), raw_data, cost)
+        (result.slice().to_vec(), raw_data, Gas(cost))
     }
 }
diff --git a/arbitrator/stylus/src/host.rs b/arbitrator/stylus/src/host.rs
index 1afc1b4e51..c72cafc316 100644
--- a/arbitrator/stylus/src/host.rs
+++ b/arbitrator/stylus/src/host.rs
@@ -6,7 +6,7 @@
 use crate::env::{Escape, HostioInfo, MaybeEscape, WasmEnv, WasmEnvMut};
 use arbutil::{
     evm::{
-        api::{DataReader, EvmApi},
+        api::{DataReader, EvmApi, Gas, Ink},
         EvmData,
     },
     Color,
@@ -82,7 +82,7 @@ where
         println!("{} {text}", "Stylus says:".yellow());
     }
 
-    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], end_ink: u64) {
+    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], end_ink: Ink) {
         let start_ink = self.start_ink;
         self.evm_api
             .capture_hostio(name, args, outs, start_ink, end_ink);
@@ -168,7 +168,7 @@ pub(crate) fn call_contract<D: DataReader, E: EvmApi<D>>(
 ) -> Result<u8, Escape> {
     hostio!(
         env,
-        call_contract(contract, data, data_len, value, gas, ret_len)
+        call_contract(contract, data, data_len, value, Gas(gas), ret_len)
     )
 }
 
@@ -182,7 +182,7 @@ pub(crate) fn delegate_call_contract<D: DataReader, E: EvmApi<D>>(
 ) -> Result<u8, Escape> {
     hostio!(
         env,
-        delegate_call_contract(contract, data, data_len, gas, ret_len)
+        delegate_call_contract(contract, data, data_len, Gas(gas), ret_len)
     )
 }
 
@@ -196,7 +196,7 @@ pub(crate) fn static_call_contract<D: DataReader, E: EvmApi<D>>(
 ) -> Result<u8, Escape> {
     hostio!(
         env,
-        static_call_contract(contract, data, data_len, gas, ret_len)
+        static_call_contract(contract, data, data_len, Gas(gas), ret_len)
     )
 }
 
@@ -334,13 +334,13 @@ pub(crate) fn contract_address<D: DataReader, E: EvmApi<D>>(
 pub(crate) fn evm_gas_left<D: DataReader, E: EvmApi<D>>(
     mut env: WasmEnvMut<D, E>,
 ) -> Result<u64, Escape> {
-    hostio!(env, evm_gas_left())
+    hostio!(env, evm_gas_left()).map(|g| g.0)
 }
 
 pub(crate) fn evm_ink_left<D: DataReader, E: EvmApi<D>>(
     mut env: WasmEnvMut<D, E>,
 ) -> Result<u64, Escape> {
-    hostio!(env, evm_ink_left())
+    hostio!(env, evm_ink_left()).map(|i| i.0)
 }
 
 pub(crate) fn math_div<D: DataReader, E: EvmApi<D>>(
diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs
index 5962817d78..e7f10c2400 100644
--- a/arbitrator/stylus/src/lib.rs
+++ b/arbitrator/stylus/src/lib.rs
@@ -3,7 +3,7 @@
 
 use arbutil::{
     evm::{
-        api::DataReader,
+        api::{DataReader, Gas, Ink},
         req::EvmApiRequestor,
         user::{UserOutcome, UserOutcomeKind},
         EvmData,
@@ -279,7 +279,7 @@ pub unsafe extern "C" fn stylus_call(
     let evm_api = EvmApiRequestor::new(req_handler);
     let pricing = config.pricing;
     let output = &mut *output;
-    let ink = pricing.gas_to_ink(*gas);
+    let ink = pricing.gas_to_ink(Gas(*gas));
 
     // Safety: module came from compile_user_wasm and we've paid for memory expansion
     let instance = unsafe {
@@ -302,10 +302,10 @@ pub unsafe extern "C" fn stylus_call(
         Ok(outcome) => output.write_outcome(outcome),
     };
     let ink_left = match status {
-        UserOutcomeKind::OutOfStack => 0, // take all gas when out of stack
+        UserOutcomeKind::OutOfStack => Ink(0), // take all gas when out of stack
         _ => instance.ink_left().into(),
     };
-    *gas = pricing.ink_to_gas(ink_left);
+    *gas = pricing.ink_to_gas(ink_left).0;
     status
 }
 
diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs
index c751a670cc..0fbdb342f3 100644
--- a/arbitrator/stylus/src/native.rs
+++ b/arbitrator/stylus/src/native.rs
@@ -8,7 +8,7 @@ use crate::{
 };
 use arbutil::{
     evm::{
-        api::{DataReader, EvmApi},
+        api::{DataReader, EvmApi, Ink},
         EvmData,
     },
     operator::OperatorCode,
@@ -270,7 +270,7 @@ impl<D: DataReader, E: EvmApi<D>> NativeInstance<D, E> {
         global.set(store, value.into()).map_err(ErrReport::msg)
     }
 
-    pub fn call_func<R>(&mut self, func: TypedFunction<(), R>, ink: u64) -> Result<R>
+    pub fn call_func<R>(&mut self, func: TypedFunction<(), R>, ink: Ink) -> Result<R>
     where
         R: WasmTypeList,
     {
diff --git a/arbitrator/stylus/src/run.rs b/arbitrator/stylus/src/run.rs
index 8e673a25e5..6cbb0cfb42 100644
--- a/arbitrator/stylus/src/run.rs
+++ b/arbitrator/stylus/src/run.rs
@@ -4,18 +4,18 @@
 #![allow(clippy::redundant_closure_call)]
 
 use crate::{env::Escape, native::NativeInstance};
-use arbutil::evm::api::{DataReader, EvmApi};
+use arbutil::evm::api::{DataReader, EvmApi, Ink};
 use arbutil::evm::user::UserOutcome;
 use eyre::{eyre, Result};
 use prover::machine::Machine;
 use prover::programs::{prelude::*, STYLUS_ENTRY_POINT};
 
 pub trait RunProgram {
-    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: u64) -> Result<UserOutcome>;
+    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: Ink) -> Result<UserOutcome>;
 }
 
 impl RunProgram for Machine {
-    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: u64) -> Result<UserOutcome> {
+    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: Ink) -> Result<UserOutcome> {
         macro_rules! call {
             ($module:expr, $func:expr, $args:expr) => {
                 call!($module, $func, $args, |error| UserOutcome::Failure(error))
@@ -65,7 +65,7 @@ impl RunProgram for Machine {
 }
 
 impl<D: DataReader, E: EvmApi<D>> RunProgram for NativeInstance<D, E> {
-    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: u64) -> Result<UserOutcome> {
+    fn run_main(&mut self, args: &[u8], config: StylusConfig, ink: Ink) -> Result<UserOutcome> {
         use UserOutcome::*;
 
         self.set_ink(ink);
diff --git a/arbitrator/stylus/src/test/api.rs b/arbitrator/stylus/src/test/api.rs
index 66d600a6f7..7a5af6f89f 100644
--- a/arbitrator/stylus/src/test/api.rs
+++ b/arbitrator/stylus/src/test/api.rs
@@ -4,7 +4,7 @@
 use crate::{native, run::RunProgram};
 use arbutil::{
     evm::{
-        api::{EvmApi, VecReader},
+        api::{EvmApi, Gas, Ink, VecReader},
         user::UserOutcomeKind,
         EvmData,
     },
@@ -68,24 +68,24 @@ impl TestEvmApi {
 }
 
 impl EvmApi<VecReader> for TestEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: Gas) -> (Bytes32, Gas) {
         let storage = &mut self.storage.lock();
         let storage = storage.get_mut(&self.program).unwrap();
         let value = storage.get(&key).cloned().unwrap_or_default();
-        (value, 2100) // pretend worst case
+        (value, Gas(2100)) // pretend worst case
     }
 
-    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> u64 {
+    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> Gas {
         let storage = &mut self.storage.lock();
         let storage = storage.get_mut(&self.program).unwrap();
         storage.insert(key, value);
-        0
+        Gas(0)
     }
 
-    fn flush_storage_cache(&mut self, _clear: bool, _gas_left: u64) -> Result<u64> {
+    fn flush_storage_cache(&mut self, _clear: bool, _gas_left: Gas) -> Result<Gas> {
         let storage = &mut self.storage.lock();
         let storage = storage.get_mut(&self.program).unwrap();
-        Ok(22100 * storage.len() as u64) // pretend worst case
+        Ok(Gas(22100) * storage.len() as u64) // pretend worst case
     }
 
     fn get_transient_bytes32(&mut self, _key: Bytes32) -> Bytes32 {
@@ -102,10 +102,10 @@ impl EvmApi<VecReader> for TestEvmApi {
         &mut self,
         contract: Bytes20,
         calldata: &[u8],
-        _gas_left: u64,
-        gas_req: u64,
+        _gas_left: Gas,
+        gas_req: Gas,
         _value: Bytes32,
-    ) -> (u32, u64, UserOutcomeKind) {
+    ) -> (u32, Gas, UserOutcomeKind) {
         let compile = self.compile.clone();
         let evm_data = self.evm_data;
         let config = *self.configs.lock().get(&contract).unwrap();
@@ -122,7 +122,7 @@ impl EvmApi<VecReader> for TestEvmApi {
         let (status, outs) = outcome.into_data();
         let outs_len = outs.len() as u32;
 
-        let ink_left: u64 = native.ink_left().into();
+        let ink_left: Ink = native.ink_left().into();
         let gas_left = config.pricing.ink_to_gas(ink_left);
         *self.write_result.lock() = outs;
         (outs_len, gas - gas_left, status)
@@ -132,9 +132,9 @@ impl EvmApi<VecReader> for TestEvmApi {
         &mut self,
         _contract: Bytes20,
         _calldata: &[u8],
-        _gas_left: u64,
-        _gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        _gas_left: Gas,
+        _gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         todo!("delegate call not yet supported")
     }
 
@@ -142,9 +142,9 @@ impl EvmApi<VecReader> for TestEvmApi {
         &mut self,
         contract: Bytes20,
         calldata: &[u8],
-        gas_left: u64,
-        gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        gas_left: Gas,
+        gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         println!("note: overriding static call with call");
         self.contract_call(contract, calldata, gas_left, gas_req, Bytes32::default())
     }
@@ -153,8 +153,8 @@ impl EvmApi<VecReader> for TestEvmApi {
         &mut self,
         _code: Vec<u8>,
         _endowment: Bytes32,
-        _gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        _gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         unimplemented!("create1 not supported")
     }
 
@@ -163,8 +163,8 @@ impl EvmApi<VecReader> for TestEvmApi {
         _code: Vec<u8>,
         _endowment: Bytes32,
         _salt: Bytes32,
-        _gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        _gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         unimplemented!("create2 not supported")
     }
 
@@ -176,19 +176,19 @@ impl EvmApi<VecReader> for TestEvmApi {
         Ok(()) // pretend a log was emitted
     }
 
-    fn account_balance(&mut self, _address: Bytes20) -> (Bytes32, u64) {
+    fn account_balance(&mut self, _address: Bytes20) -> (Bytes32, Gas) {
         unimplemented!()
     }
 
-    fn account_code(&mut self, _address: Bytes20, _gas_left: u64) -> (VecReader, u64) {
+    fn account_code(&mut self, _address: Bytes20, _gas_left: Gas) -> (VecReader, Gas) {
         unimplemented!()
     }
 
-    fn account_codehash(&mut self, _address: Bytes20) -> (Bytes32, u64) {
+    fn account_codehash(&mut self, _address: Bytes20) -> (Bytes32, Gas) {
         unimplemented!()
     }
 
-    fn add_pages(&mut self, new: u16) -> u64 {
+    fn add_pages(&mut self, new: u16) -> Gas {
         let model = MemoryModel::new(2, 1000);
         let (open, ever) = *self.pages.lock();
 
@@ -203,8 +203,8 @@ impl EvmApi<VecReader> for TestEvmApi {
         _name: &str,
         _args: &[u8],
         _outs: &[u8],
-        _start_ink: u64,
-        _end_ink: u64,
+        _start_ink: Ink,
+        _end_ink: Ink,
     ) {
         unimplemented!()
     }
diff --git a/arbitrator/stylus/src/test/mod.rs b/arbitrator/stylus/src/test/mod.rs
index 00c9c62ae4..3fd0faede8 100644
--- a/arbitrator/stylus/src/test/mod.rs
+++ b/arbitrator/stylus/src/test/mod.rs
@@ -3,7 +3,10 @@
 
 use crate::{env::WasmEnv, native::NativeInstance, run::RunProgram, test::api::TestEvmApi};
 use arbutil::{
-    evm::{api::VecReader, user::UserOutcome},
+    evm::{
+        api::{Ink, VecReader},
+        user::UserOutcome,
+    },
     Bytes20, Bytes32, Color,
 };
 use eyre::{bail, Result};
@@ -41,7 +44,7 @@ impl TestInstance {
         };
         let mut native = Self::new_from_store(path, store, imports)?;
         native.set_meter_data();
-        native.set_ink(u64::MAX);
+        native.set_ink(Ink(u64::MAX));
         native.set_stack(u32::MAX);
         Ok(native)
     }
@@ -107,8 +110,8 @@ fn expensive_add(op: &Operator, _tys: &SigMap) -> u64 {
     }
 }
 
-pub fn random_ink(min: u64) -> u64 {
-    rand::thread_rng().gen_range(min..=u64::MAX)
+pub fn random_ink(min: u64) -> Ink {
+    Ink(rand::thread_rng().gen_range(min..=u64::MAX))
 }
 
 pub fn random_bytes20() -> Bytes20 {
@@ -135,7 +138,7 @@ fn uniform_cost_config() -> StylusConfig {
     stylus_config
 }
 
-fn test_configs() -> (CompileConfig, StylusConfig, u64) {
+fn test_configs() -> (CompileConfig, StylusConfig, Ink) {
     (
         test_compile_config(),
         uniform_cost_config(),
@@ -165,12 +168,12 @@ fn new_test_machine(path: &str, compile: &CompileConfig) -> Result<Machine> {
         Arc::new(|_, _, _| panic!("tried to read preimage")),
         Some(stylus_data),
     )?;
-    mach.set_ink(u64::MAX);
+    mach.set_ink(Ink(u64::MAX));
     mach.set_stack(u32::MAX);
     Ok(mach)
 }
 
-fn run_native(native: &mut TestInstance, args: &[u8], ink: u64) -> Result<Vec<u8>> {
+fn run_native(native: &mut TestInstance, args: &[u8], ink: Ink) -> Result<Vec<u8>> {
     let config = native.env().config.expect("no config");
     match native.run_main(args, config, ink)? {
         UserOutcome::Success(output) => Ok(output),
@@ -182,7 +185,7 @@ fn run_machine(
     machine: &mut Machine,
     args: &[u8],
     config: StylusConfig,
-    ink: u64,
+    ink: Ink,
 ) -> Result<Vec<u8>> {
     match machine.run_main(args, config, ink)? {
         UserOutcome::Success(output) => Ok(output),
diff --git a/arbitrator/stylus/src/test/native.rs b/arbitrator/stylus/src/test/native.rs
index 9669932a03..672bdd179c 100644
--- a/arbitrator/stylus/src/test/native.rs
+++ b/arbitrator/stylus/src/test/native.rs
@@ -16,7 +16,7 @@ use crate::{
 use arbutil::{
     crypto,
     evm::{
-        api::EvmApi,
+        api::{EvmApi, Gas, Ink},
         user::{UserOutcome, UserOutcomeKind},
     },
     format, Bytes20, Bytes32, Color,
@@ -48,8 +48,8 @@ fn test_ink() -> Result<()> {
 
     macro_rules! exhaust {
         ($ink:expr) => {
-            native.set_ink($ink);
-            assert_eq!(native.ink_left(), MachineMeter::Ready($ink));
+            native.set_ink(Ink($ink));
+            assert_eq!(native.ink_left(), MachineMeter::Ready(Ink($ink)));
             assert!(add_one.call(&mut native.store, 32).is_err());
             assert_eq!(native.ink_left(), MachineMeter::Exhausted);
         };
@@ -59,12 +59,12 @@ fn test_ink() -> Result<()> {
     exhaust!(50);
     exhaust!(99);
 
-    let mut ink_left = 500;
+    let mut ink_left = Ink(500);
     native.set_ink(ink_left);
-    while ink_left > 0 {
+    while ink_left > Ink(0) {
         assert_eq!(native.ink_left(), MachineMeter::Ready(ink_left));
         assert_eq!(add_one.call(&mut native.store, 64)?, 65);
-        ink_left -= 100;
+        ink_left -= Ink(100);
     }
     assert!(add_one.call(&mut native.store, 32).is_err());
     assert_eq!(native.ink_left(), MachineMeter::Exhausted);
@@ -198,7 +198,7 @@ fn test_import_export_safety() -> Result<()> {
         let mut bin = bin?;
         assert!(bin.clone().instrument(&compile, codehash).is_err());
         compile.debug.debug_info = false;
-        assert!(bin.instrument(&compile, &codehash).is_err());
+        assert!(bin.instrument(&compile, codehash).is_err());
 
         if both {
             assert!(TestInstance::new_test(file, compile).is_err());
@@ -268,7 +268,7 @@ fn test_heap() -> Result<()> {
         assert_eq!(pages, 128);
 
         let used = config.pricing.ink_to_gas(ink - native.ink_ready()?);
-        ensure!((used as i64 - 32_000_000).abs() < 3_000, "wrong ink");
+        ensure!((used.0 as i64 - 32_000_000).abs() < 3_000, "wrong ink");
         assert_eq!(native.memory_size(), Pages(128));
 
         if step == extra {
@@ -283,7 +283,7 @@ fn test_heap() -> Result<()> {
     //     the cost should exceed a maximum u32, consuming more gas than can ever be bought
 
     let (mut native, _) = TestInstance::new_with_evm("tests/memory2.wat", &compile, config)?;
-    let outcome = native.run_main(&[], config, config.pricing.ink_to_gas(u32::MAX.into()))?;
+    let outcome = native.run_main(&[], config, config.pricing.gas_to_ink(Gas(u32::MAX.into())))?;
     assert_eq!(outcome.kind(), UserOutcomeKind::OutOfInk);
 
     // ensure we reject programs with excessive footprints
@@ -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).0, Bytes32(value));
+    assert_eq!(evm.get_bytes32(key.into(), Gas(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).0, value);
+        assert_eq!(evm.get_bytes32(key, Gas(0)).0, value);
     }
     Ok(())
 }
diff --git a/arbitrator/stylus/src/test/wavm.rs b/arbitrator/stylus/src/test/wavm.rs
index e707cf490a..729cfebf2f 100644
--- a/arbitrator/stylus/src/test/wavm.rs
+++ b/arbitrator/stylus/src/test/wavm.rs
@@ -2,6 +2,7 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
 use crate::test::{new_test_machine, test_compile_config};
+use arbutil::evm::api::Ink;
 use eyre::Result;
 use prover::{programs::prelude::*, Machine};
 
@@ -15,8 +16,8 @@ fn test_ink() -> Result<()> {
 
     macro_rules! exhaust {
         ($ink:expr) => {
-            machine.set_ink($ink);
-            assert_eq!(machine.ink_left(), MachineMeter::Ready($ink));
+            machine.set_ink(Ink($ink));
+            assert_eq!(machine.ink_left(), MachineMeter::Ready(Ink($ink)));
             assert!(call(machine, 32).is_err());
             assert_eq!(machine.ink_left(), MachineMeter::Exhausted);
         };
@@ -26,12 +27,12 @@ fn test_ink() -> Result<()> {
     exhaust!(50);
     exhaust!(99);
 
-    let mut ink_left = 500;
+    let mut ink_left = Ink(500);
     machine.set_ink(ink_left);
-    while ink_left > 0 {
+    while ink_left > Ink(0) {
         assert_eq!(machine.ink_left(), MachineMeter::Ready(ink_left));
         assert_eq!(call(machine, 64)?, vec![65_u32.into()]);
-        ink_left -= 100;
+        ink_left -= Ink(100);
     }
     assert!(call(machine, 32).is_err());
     assert_eq!(machine.ink_left(), MachineMeter::Exhausted);
diff --git a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
index 12a6bdbed2..35a4a31347 100644
--- a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
+++ b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
@@ -5,7 +5,7 @@ use arbutil::{
     crypto,
     evm::{
         self,
-        api::{DataReader, EvmApi},
+        api::{DataReader, EvmApi, Gas, Ink},
         storage::StorageCache,
         user::UserOutcomeKind,
         EvmData, ARBOS_VERSION_STYLUS_CHARGING_FIXES,
@@ -88,7 +88,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     }
 
     fn say<D: Display>(&self, text: D);
-    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], end_ink: u64);
+    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], end_ink: Ink);
 
     fn write_bytes20(&self, ptr: GuestPtr, src: Bytes20) -> Result<(), Self::MemoryErr> {
         self.write_slice(ptr, &src.0)
@@ -147,7 +147,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
 
         // 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
+            Gas(EVM_API_INK.0)
         } else {
             self.pricing().ink_to_gas(EVM_API_INK)
         };
@@ -253,7 +253,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         data: GuestPtr,
         data_len: u32,
         value: GuestPtr,
-        gas: u64,
+        gas: Gas,
         ret_len: GuestPtr,
     ) -> Result<u8, Self::Err> {
         let value = Some(value);
@@ -282,7 +282,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         contract: GuestPtr,
         data: GuestPtr,
         data_len: u32,
-        gas: u64,
+        gas: Gas,
         ret_len: GuestPtr,
     ) -> Result<u8, Self::Err> {
         let call = |api: &mut Self::A, contract, data: &_, left, req, _| {
@@ -312,7 +312,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         contract: GuestPtr,
         data: GuestPtr,
         data_len: u32,
-        gas: u64,
+        gas: Gas,
         ret_len: GuestPtr,
     ) -> Result<u8, Self::Err> {
         let call = |api: &mut Self::A, contract, data: &_, left, req, _| {
@@ -329,7 +329,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         calldata: GuestPtr,
         calldata_len: u32,
         value: Option<GuestPtr>,
-        gas: u64,
+        gas: Gas,
         return_data_len: GuestPtr,
         call: F,
         name: &str,
@@ -339,10 +339,10 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
             &mut Self::A,
             Address,
             &[u8],
-            u64,
-            u64,
+            Gas,
+            Gas,
             Option<Wei>,
-        ) -> (u32, u64, UserOutcomeKind),
+        ) -> (u32, Gas, UserOutcomeKind),
     {
         self.buy_ink(HOSTIO_INK + 3 * PTR_INK + EVM_API_INK)?;
         self.pay_for_read(calldata_len)?;
@@ -465,12 +465,12 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         salt: Option<GuestPtr>,
         contract: GuestPtr,
         revert_data_len: GuestPtr,
-        cost: u64,
+        cost: Ink,
         call: F,
         name: &str,
     ) -> Result<(), Self::Err>
     where
-        F: FnOnce(&mut Self::A, Vec<u8>, Bytes32, Option<Wei>, u64) -> (Result<Address>, u32, u64),
+        F: FnOnce(&mut Self::A, Vec<u8>, Bytes32, Option<Wei>, Gas) -> (Result<Address>, u32, Gas),
     {
         self.buy_ink(HOSTIO_INK + cost)?;
         self.pay_for_read(code_len)?;
@@ -745,7 +745,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     /// equivalent to that of the EVM's [`GAS`] opcode.
     ///
     /// [`GAS`]: https://www.evm.codes/#5a
-    fn evm_gas_left(&mut self) -> Result<u64, Self::Err> {
+    fn evm_gas_left(&mut self) -> Result<Gas, Self::Err> {
         self.buy_ink(HOSTIO_INK)?;
         let gas = self.gas_left()?;
         trace!("evm_gas_left", self, &[], be!(gas), gas)
@@ -757,7 +757,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     ///
     /// [`GAS`]: https://www.evm.codes/#5a
     /// [`Ink and Gas`]: https://developer.arbitrum.io/TODO
-    fn evm_ink_left(&mut self) -> Result<u64, Self::Err> {
+    fn evm_ink_left(&mut self) -> Result<Ink, Self::Err> {
         self.buy_ink(HOSTIO_INK)?;
         let ink = self.ink_ready()?;
         trace!("evm_ink_left", self, &[], be!(ink), ink)
diff --git a/arbitrator/wasm-libraries/user-host/src/host.rs b/arbitrator/wasm-libraries/user-host/src/host.rs
index abe55b8c12..5ec2ece2c3 100644
--- a/arbitrator/wasm-libraries/user-host/src/host.rs
+++ b/arbitrator/wasm-libraries/user-host/src/host.rs
@@ -2,7 +2,7 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
 use crate::program::Program;
-use arbutil::evm::user::UserOutcomeKind;
+use arbutil::evm::{api::Gas, user::UserOutcomeKind};
 use caller_env::GuestPtr;
 use user_host_trait::UserHost;
 
@@ -77,7 +77,14 @@ pub unsafe extern "C" fn user_host__call_contract(
     gas: u64,
     ret_len: GuestPtr,
 ) -> u8 {
-    hostio!(call_contract(contract, data, data_len, value, gas, ret_len))
+    hostio!(call_contract(
+        contract,
+        data,
+        data_len,
+        value,
+        Gas(gas),
+        ret_len
+    ))
 }
 
 #[no_mangle]
@@ -89,7 +96,11 @@ pub unsafe extern "C" fn user_host__delegate_call_contract(
     ret_len: GuestPtr,
 ) -> u8 {
     hostio!(delegate_call_contract(
-        contract, data, data_len, gas, ret_len
+        contract,
+        data,
+        data_len,
+        Gas(gas),
+        ret_len
     ))
 }
 
@@ -101,7 +112,13 @@ pub unsafe extern "C" fn user_host__static_call_contract(
     gas: u64,
     ret_len: GuestPtr,
 ) -> u8 {
-    hostio!(static_call_contract(contract, data, data_len, gas, ret_len))
+    hostio!(static_call_contract(
+        contract,
+        data,
+        data_len,
+        Gas(gas),
+        ret_len
+    ))
 }
 
 #[no_mangle]
@@ -207,12 +224,12 @@ pub unsafe extern "C" fn user_host__contract_address(ptr: GuestPtr) {
 
 #[no_mangle]
 pub unsafe extern "C" fn user_host__evm_gas_left() -> u64 {
-    hostio!(evm_gas_left())
+    hostio!(evm_gas_left()).0
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn user_host__evm_ink_left() -> u64 {
-    hostio!(evm_ink_left())
+    hostio!(evm_ink_left()).0
 }
 
 #[no_mangle]
diff --git a/arbitrator/wasm-libraries/user-host/src/ink.rs b/arbitrator/wasm-libraries/user-host/src/ink.rs
index e01e616e07..bde7cfc1c0 100644
--- a/arbitrator/wasm-libraries/user-host/src/ink.rs
+++ b/arbitrator/wasm-libraries/user-host/src/ink.rs
@@ -2,6 +2,7 @@
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
 use crate::program::Program;
+use arbutil::evm::api::Ink;
 use prover::programs::{
     config::PricingParams,
     prelude::{GasMeteredMachine, MachineMeter, MeteredMachine},
@@ -18,7 +19,7 @@ impl MeteredMachine for Program {
     fn ink_left(&self) -> MachineMeter {
         unsafe {
             match user_ink_status() {
-                0 => MachineMeter::Ready(user_ink_left()),
+                0 => MachineMeter::Ready(Ink(user_ink_left())),
                 _ => MachineMeter::Exhausted,
             }
         }
@@ -26,7 +27,7 @@ impl MeteredMachine for Program {
 
     fn set_meter(&mut self, meter: MachineMeter) {
         unsafe {
-            user_set_ink(meter.ink(), meter.status());
+            user_set_ink(meter.ink().0, meter.status());
         }
     }
 }
diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs
index f4c402fd97..cb9f046cdb 100644
--- a/arbitrator/wasm-libraries/user-host/src/link.rs
+++ b/arbitrator/wasm-libraries/user-host/src/link.rs
@@ -3,7 +3,11 @@
 
 use crate::program::Program;
 use arbutil::{
-    evm::{user::UserOutcomeKind, EvmData},
+    evm::{
+        api::{Gas, Ink},
+        user::UserOutcomeKind,
+        EvmData,
+    },
     format::DebugBytes,
     heapify, Bytes20, Bytes32,
 };
@@ -120,11 +124,11 @@ pub unsafe extern "C" fn programs__new_program(
 
     // buy ink
     let pricing = config.pricing;
-    let ink = pricing.gas_to_ink(gas);
+    let ink = pricing.gas_to_ink(Gas(gas));
 
     // link the program and ready its instrumentation
     let module = wavm_link_module(&MemoryLeaf(*module_hash));
-    program_set_ink(module, ink);
+    program_set_ink(module, ink.0);
     program_set_stack(module, config.max_depth);
 
     // provide arguments
@@ -175,7 +179,7 @@ pub unsafe extern "C" fn programs__set_response(
         id,
         STATIC_MEM.read_slice(result_ptr, result_len),
         STATIC_MEM.read_slice(raw_data_ptr, raw_data_len),
-        gas,
+        Gas(gas),
     );
 }
 
@@ -207,7 +211,7 @@ pub unsafe extern "C" fn program_internal__set_done(mut status: UserOutcomeKind)
     let program = Program::current();
     let module = program.module;
     let mut outs = program.outs.as_slice();
-    let mut ink_left = program_ink_left(module);
+    let mut ink_left = Ink(program_ink_left(module));
 
     // apply any early exit codes
     if let Some(early) = program.early_exit {
@@ -218,12 +222,12 @@ pub unsafe extern "C" fn program_internal__set_done(mut status: UserOutcomeKind)
     if program_ink_status(module) != 0 {
         status = OutOfInk;
         outs = &[];
-        ink_left = 0;
+        ink_left = Ink(0);
     }
     if program_stack_left(module) == 0 {
         status = OutOfStack;
         outs = &[];
-        ink_left = 0;
+        ink_left = Ink(0);
     }
 
     let gas_left = program.config.pricing.ink_to_gas(ink_left);
diff --git a/arbitrator/wasm-libraries/user-host/src/program.rs b/arbitrator/wasm-libraries/user-host/src/program.rs
index 4199a691f7..7b3782b2e5 100644
--- a/arbitrator/wasm-libraries/user-host/src/program.rs
+++ b/arbitrator/wasm-libraries/user-host/src/program.rs
@@ -3,7 +3,7 @@
 
 use arbutil::{
     evm::{
-        api::{EvmApiMethod, VecReader, EVM_API_METHOD_REQ_OFFSET},
+        api::{EvmApiMethod, Gas, Ink, VecReader, EVM_API_METHOD_REQ_OFFSET},
         req::{EvmApiRequestor, RequestHandler},
         user::UserOutcomeKind,
         EvmData,
@@ -49,7 +49,7 @@ static mut LAST_REQUEST_ID: u32 = 0x10000;
 #[derive(Clone)]
 pub(crate) struct UserHostRequester {
     data: Option<Vec<u8>>,
-    answer: Option<(Vec<u8>, VecReader, u64)>,
+    answer: Option<(Vec<u8>, VecReader, Gas)>,
     req_type: u32,
     id: u32,
 }
@@ -95,7 +95,7 @@ impl UserHostRequester {
         req_id: u32,
         result: Vec<u8>,
         raw_data: Vec<u8>,
-        gas: u64,
+        gas: Gas,
     ) {
         self.answer = Some((result, VecReader::new(raw_data), gas));
         if req_id != self.id {
@@ -130,7 +130,7 @@ impl UserHostRequester {
     }
 
     #[no_mangle]
-    unsafe fn send_request(&mut self, req_type: u32, data: Vec<u8>) -> (Vec<u8>, VecReader, u64) {
+    unsafe fn send_request(&mut self, req_type: u32, data: Vec<u8>) -> (Vec<u8>, VecReader, Gas) {
         let req_id = self.set_request(req_type, &data);
         compiler_fence(Ordering::SeqCst);
 
@@ -149,7 +149,7 @@ impl RequestHandler<VecReader> for UserHostRequester {
         &mut self,
         req_type: EvmApiMethod,
         req_data: impl AsRef<[u8]>,
-    ) -> (Vec<u8>, VecReader, u64) {
+    ) -> (Vec<u8>, VecReader, Gas) {
         unsafe {
             self.send_request(
                 req_type as u32 + EVM_API_METHOD_REQ_OFFSET,
@@ -265,7 +265,7 @@ impl UserHost<VecReader> for Program {
         println!("{} {text}", "Stylus says:".yellow());
     }
 
-    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], _end_ink: u64) {
+    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], _end_ink: Ink) {
         let args = hex::encode(args);
         let outs = hex::encode(outs);
         println!("Error: unexpected hostio tracing info for {name} while proving: {args}, {outs}");
diff --git a/arbitrator/wasm-libraries/user-test/src/host.rs b/arbitrator/wasm-libraries/user-test/src/host.rs
index f2912eaae3..f1b4506414 100644
--- a/arbitrator/wasm-libraries/user-test/src/host.rs
+++ b/arbitrator/wasm-libraries/user-test/src/host.rs
@@ -2,6 +2,7 @@
 // For license information, see https://github.com/nitro/blob/master/LICENSE
 
 use crate::program::Program;
+use arbutil::evm::api::Gas;
 use caller_env::GuestPtr;
 use user_host_trait::UserHost;
 
@@ -63,7 +64,14 @@ pub unsafe extern "C" fn vm_hooks__call_contract(
     gas: u64,
     ret_len: GuestPtr,
 ) -> u8 {
-    hostio!(call_contract(contract, data, data_len, value, gas, ret_len))
+    hostio!(call_contract(
+        contract,
+        data,
+        data_len,
+        value,
+        Gas(gas),
+        ret_len
+    ))
 }
 
 #[no_mangle]
@@ -75,7 +83,11 @@ pub unsafe extern "C" fn vm_hooks__delegate_call_contract(
     ret_len: GuestPtr,
 ) -> u8 {
     hostio!(delegate_call_contract(
-        contract, data, data_len, gas, ret_len
+        contract,
+        data,
+        data_len,
+        Gas(gas),
+        ret_len
     ))
 }
 
@@ -87,7 +99,13 @@ pub unsafe extern "C" fn vm_hooks__static_call_contract(
     gas: u64,
     ret_len: GuestPtr,
 ) -> u8 {
-    hostio!(static_call_contract(contract, data, data_len, gas, ret_len))
+    hostio!(static_call_contract(
+        contract,
+        data,
+        data_len,
+        Gas(gas),
+        ret_len
+    ))
 }
 
 #[no_mangle]
@@ -189,12 +207,12 @@ pub unsafe extern "C" fn vm_hooks__contract_address(ptr: GuestPtr) {
 
 #[no_mangle]
 pub unsafe extern "C" fn vm_hooks__evm_gas_left() -> u64 {
-    hostio!(evm_gas_left())
+    hostio!(evm_gas_left()).0
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn vm_hooks__evm_ink_left() -> u64 {
-    hostio!(evm_ink_left())
+    hostio!(evm_ink_left()).0
 }
 
 #[no_mangle]
diff --git a/arbitrator/wasm-libraries/user-test/src/ink.rs b/arbitrator/wasm-libraries/user-test/src/ink.rs
index fca658e59b..72ecfadd96 100644
--- a/arbitrator/wasm-libraries/user-test/src/ink.rs
+++ b/arbitrator/wasm-libraries/user-test/src/ink.rs
@@ -2,6 +2,7 @@
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
 use crate::{program::Program, CONFIG};
+use arbutil::evm::api::Ink;
 use prover::programs::{
     config::PricingParams,
     prelude::{GasMeteredMachine, MachineMeter, MeteredMachine},
@@ -18,7 +19,7 @@ impl MeteredMachine for Program {
     fn ink_left(&self) -> MachineMeter {
         unsafe {
             match user_ink_status() {
-                0 => MachineMeter::Ready(user_ink_left()),
+                0 => MachineMeter::Ready(Ink(user_ink_left())),
                 _ => MachineMeter::Exhausted,
             }
         }
@@ -26,7 +27,7 @@ impl MeteredMachine for Program {
 
     fn set_meter(&mut self, meter: MachineMeter) {
         unsafe {
-            user_set_ink(meter.ink(), meter.status());
+            user_set_ink(meter.ink().0, meter.status());
         }
     }
 }
diff --git a/arbitrator/wasm-libraries/user-test/src/program.rs b/arbitrator/wasm-libraries/user-test/src/program.rs
index 85b522ee74..299fca08c3 100644
--- a/arbitrator/wasm-libraries/user-test/src/program.rs
+++ b/arbitrator/wasm-libraries/user-test/src/program.rs
@@ -4,7 +4,7 @@
 use crate::{ARGS, EVER_PAGES, EVM_DATA, KEYS, LOGS, OPEN_PAGES, OUTS};
 use arbutil::{
     evm::{
-        api::{EvmApi, VecReader},
+        api::{EvmApi, Gas, Ink, VecReader},
         user::UserOutcomeKind,
         EvmData,
     },
@@ -80,7 +80,7 @@ impl UserHost<VecReader> for Program {
         println!("{} {text}", "Stylus says:".yellow());
     }
 
-    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], _end_ink: u64) {
+    fn trace(&mut self, name: &str, args: &[u8], outs: &[u8], _end_ink: Ink) {
         let args = hex::encode(args);
         let outs = hex::encode(outs);
         println!("Error: unexpected hostio tracing info for {name} while proving: {args}, {outs}");
@@ -102,18 +102,18 @@ impl Program {
 pub struct MockEvmApi;
 
 impl EvmApi<VecReader> for MockEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: Gas) -> (Bytes32, Gas) {
         let value = KEYS.lock().get(&key).cloned().unwrap_or_default();
-        (value, 2100) // pretend worst case
+        (value, Gas(2100)) // pretend worst case
     }
 
-    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> u64 {
+    fn cache_bytes32(&mut self, key: Bytes32, value: Bytes32) -> Gas {
         KEYS.lock().insert(key, value);
-        0
+        Gas(0)
     }
 
-    fn flush_storage_cache(&mut self, _clear: bool, _gas_left: u64) -> Result<u64> {
-        Ok(22100 * KEYS.lock().len() as u64) // pretend worst case
+    fn flush_storage_cache(&mut self, _clear: bool, _gas_left: Gas) -> Result<Gas> {
+        Ok(Gas(22100) * KEYS.lock().len() as u64) // pretend worst case
     }
 
     fn get_transient_bytes32(&mut self, _key: Bytes32) -> Bytes32 {
@@ -130,10 +130,10 @@ impl EvmApi<VecReader> for MockEvmApi {
         &mut self,
         _contract: Bytes20,
         _calldata: &[u8],
-        _gas_left: u64,
-        _gas_req: u64,
+        _gas_left: Gas,
+        _gas_req: Gas,
         _value: Bytes32,
-    ) -> (u32, u64, UserOutcomeKind) {
+    ) -> (u32, Gas, UserOutcomeKind) {
         unimplemented!()
     }
 
@@ -141,9 +141,9 @@ impl EvmApi<VecReader> for MockEvmApi {
         &mut self,
         _contract: Bytes20,
         _calldata: &[u8],
-        _gas_left: u64,
-        _gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        _gas_left: Gas,
+        _gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         unimplemented!()
     }
 
@@ -151,9 +151,9 @@ impl EvmApi<VecReader> for MockEvmApi {
         &mut self,
         _contract: Bytes20,
         _calldata: &[u8],
-        _gas_left: u64,
-        _gas_req: u64,
-    ) -> (u32, u64, UserOutcomeKind) {
+        _gas_left: Gas,
+        _gas_req: Gas,
+    ) -> (u32, Gas, UserOutcomeKind) {
         unimplemented!()
     }
 
@@ -161,8 +161,8 @@ impl EvmApi<VecReader> for MockEvmApi {
         &mut self,
         _code: Vec<u8>,
         _endowment: Bytes32,
-        _gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        _gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         unimplemented!()
     }
 
@@ -171,8 +171,8 @@ impl EvmApi<VecReader> for MockEvmApi {
         _code: Vec<u8>,
         _endowment: Bytes32,
         _salt: Bytes32,
-        _gas: u64,
-    ) -> (Result<Bytes20>, u32, u64) {
+        _gas: Gas,
+    ) -> (Result<Bytes20>, u32, Gas) {
         unimplemented!()
     }
 
@@ -185,19 +185,19 @@ impl EvmApi<VecReader> for MockEvmApi {
         Ok(())
     }
 
-    fn account_balance(&mut self, _address: Bytes20) -> (Bytes32, u64) {
+    fn account_balance(&mut self, _address: Bytes20) -> (Bytes32, Gas) {
         unimplemented!()
     }
 
-    fn account_code(&mut self, _address: Bytes20, _gas_left: u64) -> (VecReader, u64) {
+    fn account_code(&mut self, _address: Bytes20, _gas_left: Gas) -> (VecReader, Gas) {
         unimplemented!()
     }
 
-    fn account_codehash(&mut self, _address: Bytes20) -> (Bytes32, u64) {
+    fn account_codehash(&mut self, _address: Bytes20) -> (Bytes32, Gas) {
         unimplemented!()
     }
 
-    fn add_pages(&mut self, pages: u16) -> u64 {
+    fn add_pages(&mut self, pages: u16) -> Gas {
         let model = MemoryModel::new(2, 1000);
         unsafe {
             let (open, ever) = (OPEN_PAGES, EVER_PAGES);
@@ -212,8 +212,8 @@ impl EvmApi<VecReader> for MockEvmApi {
         _name: &str,
         _args: &[u8],
         _outs: &[u8],
-        _start_ink: u64,
-        _end_ink: u64,
+        _start_ink: Ink,
+        _end_ink: Ink,
     ) {
         unimplemented!()
     }
diff --git a/arbnode/batch_poster.go b/arbnode/batch_poster.go
index 7e044c5592..d534c39c5e 100644
--- a/arbnode/batch_poster.go
+++ b/arbnode/batch_poster.go
@@ -711,12 +711,14 @@ type batchSegments struct {
 }
 
 type buildingBatch struct {
-	segments          *batchSegments
-	startMsgCount     arbutil.MessageIndex
-	msgCount          arbutil.MessageIndex
-	haveUsefulMessage bool
-	use4844           bool
-	muxBackend        *simulatedMuxBackend
+	segments           *batchSegments
+	startMsgCount      arbutil.MessageIndex
+	msgCount           arbutil.MessageIndex
+	haveUsefulMessage  bool
+	use4844            bool
+	muxBackend         *simulatedMuxBackend
+	firstNonDelayedMsg *arbostypes.MessageWithMetadata
+	firstUsefulMsg     *arbostypes.MessageWithMetadata
 }
 
 func newBatchSegments(firstDelayed uint64, config *BatchPosterConfig, backlog uint64, use4844 bool) *batchSegments {
@@ -1171,12 +1173,6 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 		// There's nothing after the newest batch, therefore batch posting was not required
 		return false, nil
 	}
-	firstMsg, err := b.streamer.GetMessage(batchPosition.MessageCount)
-	if err != nil {
-		return false, err
-	}
-	// #nosec G115
-	firstMsgTime := time.Unix(int64(firstMsg.Message.Header.Timestamp), 0)
 
 	lastPotentialMsg, err := b.streamer.GetMessage(msgCount - 1)
 	if err != nil {
@@ -1184,7 +1180,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 	}
 
 	config := b.config()
-	forcePostBatch := config.MaxDelay <= 0 || time.Since(firstMsgTime) >= config.MaxDelay
+	forcePostBatch := config.MaxDelay <= 0
 
 	var l1BoundMaxBlockNumber uint64 = math.MaxUint64
 	var l1BoundMaxTimestamp uint64 = math.MaxUint64
@@ -1296,6 +1292,9 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 				forcePostBatch = true
 			}
 			b.building.haveUsefulMessage = true
+			if b.building.firstUsefulMsg == nil {
+				b.building.firstUsefulMsg = msg
+			}
 			break
 		}
 		if config.CheckBatchCorrectness {
@@ -1306,13 +1305,28 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 		}
 		if msg.Message.Header.Kind != arbostypes.L1MessageType_BatchPostingReport {
 			b.building.haveUsefulMessage = true
+			if b.building.firstUsefulMsg == nil {
+				b.building.firstUsefulMsg = msg
+			}
+		}
+		if !isDelayed && b.building.firstNonDelayedMsg == nil {
+			b.building.firstNonDelayedMsg = msg
 		}
 		b.building.msgCount++
 	}
 
-	if hasL1Bound && config.ReorgResistanceMargin > 0 {
-		firstMsgBlockNumber := firstMsg.Message.Header.BlockNumber
-		firstMsgTimeStamp := firstMsg.Message.Header.Timestamp
+	firstUsefulMsgTime := time.Now()
+	if b.building.firstUsefulMsg != nil {
+		// #nosec G115
+		firstUsefulMsgTime = time.Unix(int64(b.building.firstUsefulMsg.Message.Header.Timestamp), 0)
+		if time.Since(firstUsefulMsgTime) >= config.MaxDelay {
+			forcePostBatch = true
+		}
+	}
+
+	if b.building.firstNonDelayedMsg != nil && hasL1Bound && config.ReorgResistanceMargin > 0 {
+		firstMsgBlockNumber := b.building.firstNonDelayedMsg.Message.Header.BlockNumber
+		firstMsgTimeStamp := b.building.firstNonDelayedMsg.Message.Header.Timestamp
 		// #nosec G115
 		batchNearL1BoundMinBlockNumber := firstMsgBlockNumber <= arbmath.SaturatingUAdd(l1BoundMinBlockNumber, uint64(config.ReorgResistanceMargin/ethPosBlockTime))
 		// #nosec G115
@@ -1463,7 +1477,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 	}
 
 	tx, err := b.dataPoster.PostTransaction(ctx,
-		firstMsgTime,
+		firstUsefulMsgTime,
 		nonce,
 		newMeta,
 		b.seqInboxAddr,
diff --git a/arbnode/dataposter/testdata/client.crt b/arbnode/dataposter/testdata/client.crt
index 3d494be820..9171094ba5 100644
--- a/arbnode/dataposter/testdata/client.crt
+++ b/arbnode/dataposter/testdata/client.crt
@@ -1,28 +1,25 @@
 -----BEGIN CERTIFICATE-----
-MIIE0jCCA7qgAwIBAgIUPaBB3/hHMpZfGB3VOw1+mHG4LnUwDQYJKoZIhvcNAQEL
+MIIEIjCCAwqgAwIBAgIUV1axsouzA9h1Vgr2cPv17AvUrKswDQYJKoZIhvcNAQEL
 BQAwgYMxCzAJBgNVBAYTAkNIMQswCQYDVQQIDAJaSDEPMA0GA1UEBwwGWnVyaWNo
 MRYwFAYDVQQKDA1PZmZjaGFpbiBMYWJzMRIwEAYDVQQDDAlsb2NhbGhvc3QxKjAo
-BgkqhkiG9w0BCQEWG25vdGFiaWdkZWFsQG9mZmNoYWlubGFicy5jaDAeFw0yMzEw
-MTYxNDU2MjhaFw0yNDEwMTUxNDU2MjhaMIGDMQswCQYDVQQGEwJDSDELMAkGA1UE
-CAwCWkgxDzANBgNVBAcMBlp1cmljaDEWMBQGA1UECgwNT2ZmY2hhaW4gTGFiczES
-MBAGA1UEAwwJbG9jYWxob3N0MSowKAYJKoZIhvcNAQkBFhtub3RhYmlnZGVhbEBv
-ZmZjaGFpbmxhYnMuY2gwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC1
-1asfUzv07QTVwlM4o3g51ilIFEApPkpdQej/GIItLEVRQW+GI9jYuEM07wdwMhSH
-JPFNbZB3dmBuqDLx13hY03ufyeY+nab0/sO6x13kXChvIqgPRyJtkEAoYkMM3W0D
-S6HeL/6DFoTQ2xAlZb/7i/9deuUwDL3MNVSjPCm9PjFzSOFgAQQud2uUT7aENGuG
-Whw3oXz9gU/8gv3keLzcIa2PHyEW5M7jeGSYMjfW3wr0d+Z5mSNRc/U6kncKi06c
-QrMKrgFfF7a5kHgxUL7bRCGgCMemXe7VfrW6oKT11JcLWDKhe+uo6bNXUptek55H
-HfQi6x8cbM46/h3riZA3AgMBAAGjggE6MIIBNjAdBgNVHQ4EFgQUQD2BOems0+JQ
-br234cW5noMmXRIwga0GA1UdIwSBpTCBoqGBiaSBhjCBgzELMAkGA1UEBhMCQ0gx
-CzAJBgNVBAgMAlpIMQ8wDQYDVQQHDAZadXJpY2gxFjAUBgNVBAoMDU9mZmNoYWlu
-IExhYnMxEjAQBgNVBAMMCWxvY2FsaG9zdDEqMCgGCSqGSIb3DQEJARYbbm90YWJp
-Z2RlYWxAb2ZmY2hhaW5sYWJzLmNoghQ9oEHf+Ecyll8YHdU7DX6YcbgudTAJBgNV
-HRMEAjAAMAsGA1UdDwQEAwIFoDAfBgNVHREEGDAWgglsb2NhbGhvc3SCCTEyNy4w
-LjAuMTAsBglghkgBhvhCAQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNh
-dGUwDQYJKoZIhvcNAQELBQADggEBAF4EVkOZZeMIvv0JViP7NsmIl2ke/935x6Hd
-hQiLUw13XHYXzMa5/8Y5fnKjttBODpFoQlwjgI18vzuYzItYMBc2cabQJcpfG+Wq
-M3m/wl1TC2XOuHj1E4RA/nU3tslntahtXG+vkks9RN+f9irHUhDRR6AGSnSB2Gi/
-B2OGmXn7S4Qge8+fGHAjN+tlu+tOoEWP6R3if/a9UIe5EGM8QTe4zw6lr+iPrOhC
-M94pK5IEWn5IIGhr3zJIYkm/Dp+rFqhV1sqPOjjFLVCA7KJ3jVVVHlcm4Xa/+fyk
-CIm7/VAmnbeUNlMbkXNOfQMeku8Iwsu80pvf3kjhU/PgO/5oojk=
+BgkqhkiG9w0BCQEWG25vdGFiaWdkZWFsQG9mZmNoYWlubGFicy5jaDAgFw0yNDEw
+MTYwMzI1NDdaGA8yMTI0MDkyMjAzMjU0N1owgYMxCzAJBgNVBAYTAkNIMQswCQYD
+VQQIDAJaSDEPMA0GA1UEBwwGWnVyaWNoMRYwFAYDVQQKDA1PZmZjaGFpbiBMYWJz
+MRIwEAYDVQQDDAlsb2NhbGhvc3QxKjAoBgkqhkiG9w0BCQEWG25vdGFiaWdkZWFs
+QG9mZmNoYWlubGFicy5jaDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AKU5q5iwYV4/gPeWcyys561pTGV4pk+sRY2q0znsZFOYcxrjaXEjj2HGNkvH1rKy
+8Cv1ZoFW+1ejQZeLtd0qL9v5fDkdLsmCZaIYI5Bvo2CfY6KLUZ5c1q2K2GZgQk8i
+eSbqBXq+F/EwziDfheXkhDoAE05hOg684titb21eJ0ZK7f7Koam7cmbQI0lqUCrt
+MLp0cJzWnfW0SpCzahnCZ5h31BZeZIRLOxsTvg5N1wOivrdWLXGVbprNCGGhVg0E
+ZxhwI00pU/E/K4mcKjtPy/5fqe71jH7/iLYNmhRp6PrA78GilxTT79rro8ooantD
+GyQbm+Qkk2tMHHum3GOcjuECAwEAAaOBiTCBhjAdBgNVHQ4EFgQUIUFF6jA0NkRA
+1kZhJKH0W/9zJWIwCQYDVR0TBAIwADALBgNVHQ8EBAMCBaAwHwYDVR0RBBgwFoIJ
+bG9jYWxob3N0ggkxMjcuMC4wLjEwLAYJYIZIAYb4QgENBB8WHU9wZW5TU0wgR2Vu
+ZXJhdGVkIENlcnRpZmljYXRlMA0GCSqGSIb3DQEBCwUAA4IBAQCkfknujeFa0yf4
+YX/3ltP9itq4hLtAYnQF7M/uC86QdyDPsrNqhvj54qC0BnR5wGeZP3c144J2mAUr
+4j4Y/ztgFVBR4rLyatHgm0/tL/fy/UgjeSmpY4UOr1QnpNP3fIzL7hxacS4uO8v4
+wcc5KlG/xjHRcrzJaaWLldCogBMb8vlModcbeKrkvQ4hUF+zf138RtpRfcRf1X5c
+EaAtUZk+BxVYS79qL7YyESRD8YYMhIImLuiyPt2V3HQRhrjqa3mzODBLhUbNRWPX
+8/CH2UZ6TD9Hy4FVX0VZzLoDZjfi4KCTgXI3WGrDoL4FF26cSiK8HVx0qJzAWw4a
+tkkj5jtd
 -----END CERTIFICATE-----
diff --git a/arbnode/dataposter/testdata/client.key b/arbnode/dataposter/testdata/client.key
index b14941dd9f..4313d0f124 100644
--- a/arbnode/dataposter/testdata/client.key
+++ b/arbnode/dataposter/testdata/client.key
@@ -1,28 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC11asfUzv07QTV
-wlM4o3g51ilIFEApPkpdQej/GIItLEVRQW+GI9jYuEM07wdwMhSHJPFNbZB3dmBu
-qDLx13hY03ufyeY+nab0/sO6x13kXChvIqgPRyJtkEAoYkMM3W0DS6HeL/6DFoTQ
-2xAlZb/7i/9deuUwDL3MNVSjPCm9PjFzSOFgAQQud2uUT7aENGuGWhw3oXz9gU/8
-gv3keLzcIa2PHyEW5M7jeGSYMjfW3wr0d+Z5mSNRc/U6kncKi06cQrMKrgFfF7a5
-kHgxUL7bRCGgCMemXe7VfrW6oKT11JcLWDKhe+uo6bNXUptek55HHfQi6x8cbM46
-/h3riZA3AgMBAAECggEADUboCYMCpm+LqIhzNCtqswQD6QsiSwCmqs8nuKZGk9ue
-+hmZj5IpgMJZLrgvWY4s+PGfgiRR/28QCBrVXkETiZ5zirQFN4tvLlKcSK4xZf29
-FBRUCiPxck36NhiqrBNOi1Mn8BKedl4cESkvSu1cvcmeOh100HPcHfLDVqHx3qsl
-D/5yMkT2+zdhtLa+X3nkAa+3aibOvgtyfkV679e20CG6h89N9GBKkTXO8ioLZZVm
-84ksnd4FcpTo7ebJJxElEB+ZA4akPHbF6ArUmcpqtGso5GtwqqO2ZlguSn2XQT0d
-jqvOG4DwfSXk6SpE/dpWvU92fmxWAxZvGrZNgDyJ2QKBgQDyQ8NN4b80Yza/YXar
-LWx8A6B0eMc1dXgt9m3UUI+titt45jEcaXhCX01FRFTznWGmWFtJmcWBoaQVPVel
-IcDYQSxEuBUrCeI75ocv/IQtENaiX3TK7Nlz5RHfpQpfDVJq45lpiD38CGkYkAif
-9pSzC8aup4W3WR0JJZ1AOHUZaQKBgQDAJNJnaSNzB+eDWTKCIN5V9X3QMkmjsuir
-Nf2lBXHYARnlYWAbtYFG12wLJQMTNX5ewVQQrWtsdPkGPpCnPLelUTxMssrsXjej
-JlLzYUfzRBqEXMI3AA9bVdiauxId2RTcp2F81SM1keCMcuHYxrzVkBSOC9u3wCnb
-Whb6+feInwKBgQCbzgC5AcoaQwReqKvNAvWV/C8hONvFAbs8tBOGTBlbHsZvRnun
-Lh1tciUbuwp3cmvuszxiZUakS/RexIitZrvDWIbD2y+h8kVRCL1Am0HWSdH/syxF
-pXVkF5obHuVApCyxGZb8S+axRCdy6I7jcY3IaHZqtMpGVEVcMJilSKnmoQKBgQCC
-tEmgaMfhhx34nqOaG4vDA4T7LEolnh1h4g9RwztnCZC5FZ1QHA79xqrLhfjqhzgY
-cwChe6aYl5WSptq1uLrgLTuMnQ8m7QyB4h8JSkKse8ZiBctjqJnJssLutpSjUzk6
-xG2vgjk6RqpuP/PcB40K5cDlw7FJ9OFEQqthPMsi1wKBgQC0/vv5bY3DQ+wV6gUy
-nFoSa/XNHaa8y7jmmlCnWJqs6DAAQQ3VW0tPX03GYL/NDcI+PwzYDHDkSB6Qa/o8
-VzVGK1/kr/+bveNvqmi0vNb54fMFLveGgsY4Cu1cffiw8m6nYJ/V4eCsHfpF1B5L
-5HDnt5rFKt1Mi9WsUSRtxipxBA==
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQClOauYsGFeP4D3
+lnMsrOetaUxleKZPrEWNqtM57GRTmHMa42lxI49hxjZLx9aysvAr9WaBVvtXo0GX
+i7XdKi/b+Xw5HS7JgmWiGCOQb6Ngn2Oii1GeXNatithmYEJPInkm6gV6vhfxMM4g
+34Xl5IQ6ABNOYToOvOLYrW9tXidGSu3+yqGpu3Jm0CNJalAq7TC6dHCc1p31tEqQ
+s2oZwmeYd9QWXmSESzsbE74OTdcDor63Vi1xlW6azQhhoVYNBGcYcCNNKVPxPyuJ
+nCo7T8v+X6nu9Yx+/4i2DZoUaej6wO/BopcU0+/a66PKKGp7QxskG5vkJJNrTBx7
+ptxjnI7hAgMBAAECggEAAagHWVuDTl+SmmjOtMby96ETm/zOpgPTGq14up7tDo17
+sexPtUum91L2XmIde+MhVz95jJhjoqhHUw6afyIaIrlojmYFfw2omSxmxt7no2NV
+q158Lfs+R7UZoEUcxRBSaJp1/ZoEQW2800WKYRieXrp7dxCwdU9dctCiSlVkTWcU
+w+f9xr084dUIKgtICbLWRdGDvGFmr99MBZXzHg5+x8MiAVtpiNcggRfQKIg2QYQv
+xdUtfxrKHuRcbeo4QOgSR6fb772F5eO6hPfwgl0AqmSX9XyRaPox/vKcq531S95S
+JvGeAdS47Qo8Elh9rIlC/pxVdJ/Gz4sbmlYCfcXDRQKBgQDbSFUrEaOnH5ITEDy/
+SDTCbdQ3bP1FmHVoLdCRoBohb0xHZrJoOn6cmxyyHWR6dwpv+rvi1bJCScDdphJM
+zV8W5sG94PaM/dwCws4CFAwaAlMakrsNUXtMgIeub27mzX5OMTss8vjKdKbVDyAv
+XCT4idJY1EOdLA3R+JTLSszxJwKBgQDA5CSKLn4HpZI6qmR5g7HRZ5g249BbX/q8
+oszAUIFfY0ME5aujWYRmTfdWno0Y2yG9x4g9QDVNK9fUH3Ii6pNRFGc/yF3HkbsP
+kT6UW6rw9CeyyYPKjrFx7M+2kBWJ16+5noVvzWhLScMCt7IcVCKaqiJFapOkS75t
+zBYH1IX0twKBgCtFBqlM/cIIlMZ2OcZ09RQ4n9ugAgotn11DTRivQvi+AYtFVIcE
+o987LFppOl6ABus5ysFj8Zzq+MfD8XB+Rfk655gUQBJqNXPGBOicFBc9xjBEK+zg
+2zepVRyymGuquPWs+URRXY51nkYEihFOWW1BpOQqXn0xKDj6mEHVLMOZAoGAc7Ol
+k1ll8ZJIT3ZLxHPRYqmALVSjc1v0G9iPdsATijMRTUuyk84rU+5qcYOzYPh4mcyp
+FQyBrGOjF7MxFG6epSDW+fRnBEGO8jyOTBFcTSI2+dBUhFjpaUvCIGD2+nLtDitf
+IPwWFisNlYC4jrOM+jcZTYgrPX7NoDCt+k5pd6sCgYB7NMYEC9XjoXV8S3n2yni5
+y0oGLox39hh31LJ90yQ/l+oFJWn1BPnzTI6xeJTTzJjQf7padyvfw45b+3BywZHM
+TI5LWcIaA6L+tiBlgBjYa7gE3CCxh0AdV+pUa8L/R6OWAK6+lg2zNt1/ommZ2sKg
+LcbNAqMiMWH1a1el7idoBA==
 -----END PRIVATE KEY-----
diff --git a/arbnode/dataposter/testdata/localhost.crt b/arbnode/dataposter/testdata/localhost.crt
index ca33dfc8cc..8b7fb02c9a 100644
--- a/arbnode/dataposter/testdata/localhost.crt
+++ b/arbnode/dataposter/testdata/localhost.crt
@@ -1,28 +1,24 @@
 -----BEGIN CERTIFICATE-----
-MIIEwzCCA6ugAwIBAgIUHx3SdpCP5jXZE7USUqX5uRNFKPIwDQYJKoZIhvcNAQEL
-BQAwfzELMAkGA1UEBhMCQ0gxCzAJBgNVBAgMAlpIMQ8wDQYDVQQHDAZadXJpY2gx
-FjAUBgNVBAoMDU9mZmNoYWluIExhYnMxEjAQBgNVBAMMCWxvY2FsaG9zdDEmMCQG
-CSqGSIb3DQEJARYXYmlnZGVhbEBvZmZjaGFpbmxhYnMuY2gwHhcNMjMxMDE2MTQ0
-MDA1WhcNMjQxMDE1MTQ0MDA1WjB/MQswCQYDVQQGEwJDSDELMAkGA1UECAwCWkgx
-DzANBgNVBAcMBlp1cmljaDEWMBQGA1UECgwNT2ZmY2hhaW4gTGFiczESMBAGA1UE
-AwwJbG9jYWxob3N0MSYwJAYJKoZIhvcNAQkBFhdiaWdkZWFsQG9mZmNoYWlubGFi
-cy5jaDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALg7XwaIh4l2Fp8a
-MfNMdTQSMPMR0zpnicVTn/eiozWsqlAKaxmQM3PxJ0oVWW3iJ89p4rv5m+UjK6Dr
-vsUQOzl8isgyGCTMnkLtxFlyallDNRDawRcuTPuNI9NkdJm+Zz7HooLzFeBDeS13
-iRPEXr1T/4af9MjOxqFvbw5xBY9k4tc2hPp6q00948gPWKIB9Mz4thoB2Hl2rQBY
-X/WhjSnre9o9qoyBO0XAsG0mssBs1vPa9/aEp7C5cDY0HCuM1RIjhXnRpb8lC9VQ
-aC+FozDffmm23EGVpLmyPs590UOtVJdTUd6Q0TAT6d7fjCRUJ12DendQf2uMFV90
-u6Yj0zUCAwEAAaOCATUwggExMB0GA1UdDgQWBBT2B3FTGFQ49JyBgDGLoZREOIGD
-DTCBqAYDVR0jBIGgMIGdoYGEpIGBMH8xCzAJBgNVBAYTAkNIMQswCQYDVQQIDAJa
-SDEPMA0GA1UEBwwGWnVyaWNoMRYwFAYDVQQKDA1PZmZjaGFpbiBMYWJzMRIwEAYD
-VQQDDAlsb2NhbGhvc3QxJjAkBgkqhkiG9w0BCQEWF2JpZ2RlYWxAb2ZmY2hhaW5s
-YWJzLmNoghQfHdJ2kI/mNdkTtRJSpfm5E0Uo8jAJBgNVHRMEAjAAMAsGA1UdDwQE
-AwIFoDAfBgNVHREEGDAWgglsb2NhbGhvc3SCCTEyNy4wLjAuMTAsBglghkgBhvhC
-AQ0EHxYdT3BlblNTTCBHZW5lcmF0ZWQgQ2VydGlmaWNhdGUwDQYJKoZIhvcNAQEL
-BQADggEBAIkhBcnLeeNwUwb+sSG4Qm8JdeplHPMeViNfFIflUfIIYS00JA2q9w8W
-+6Nh8s6Dn20lQETUnesYj97BdqzLjFuJYAlblhE+zP8g/3Mkpu+wZAGvQjUIRyGT
-C17BEtQQgAnv5pD22jr9hpLl2KowN6Oo1gzilCA+AtMkNZFIGDOxzuIv2u8rSD89
-R/V6UEDMCgusFJnZ/GzKkUNbsrAfNUezNUal+KzMhHGHBwg4jfCNhnAAB43eRtJA
-0pSRMMLcUEQnVotXDXYC3DhJmkYp1uXOH/tWs6z9xForOkWFxNMVj+zUWBi7n3Jw
-N2BXlb64D96uor13U0dmvQJ72ooJc+A=
+MIIEFzCCAv+gAwIBAgITSiI3ITH8yVNHC4Bh412fjdSR2TANBgkqhkiG9w0BAQsF
+ADB/MQswCQYDVQQGEwJDSDELMAkGA1UECAwCWkgxDzANBgNVBAcMBlp1cmljaDEW
+MBQGA1UECgwNT2ZmY2hhaW4gTGFiczESMBAGA1UEAwwJbG9jYWxob3N0MSYwJAYJ
+KoZIhvcNAQkBFhdiaWdkZWFsQG9mZmNoYWlubGFicy5jaDAgFw0yNDEwMTYwMzI1
+NDdaGA8yMTI0MDkyMjAzMjU0N1owfzELMAkGA1UEBhMCQ0gxCzAJBgNVBAgMAlpI
+MQ8wDQYDVQQHDAZadXJpY2gxFjAUBgNVBAoMDU9mZmNoYWluIExhYnMxEjAQBgNV
+BAMMCWxvY2FsaG9zdDEmMCQGCSqGSIb3DQEJARYXYmlnZGVhbEBvZmZjaGFpbmxh
+YnMuY2gwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDK4BRVZ0nU98/f
+l+QC4fF60oNtlMPCC/2R6GZoWz7VyhrrXBuol+F9vboAePxLgxeIr/pwHAbFWlW2
+ueAsN9dorC2waf5PDhfOE0gI6w7LysTkO5n7oMFf1KYPSpPJ15WxlobZR8qWeroR
+we7z44tQ2F+es+HaqBrrk7jm0GS9AqaledN/ay9SP4CBu029F6nWDnK+VpNWuoN4
+A/pnwGFWrxDf0ftN7BxnxzzdsWs64+kYfz91Mojce2UKGuDTuk/oqOnHhX34bFDc
+/e9KGAQqP1I+RuCJmQXW5b55+3WgpvT3u3Mp7478C+AK8GthPjja7go48nHp3uby
+drNpTw+bAgMBAAGjgYkwgYYwHQYDVR0OBBYEFG09BO7OJcjB3fRFhPCsjQ6ICb2E
+MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgWgMB8GA1UdEQQYMBaCCWxvY2FsaG9zdIIJ
+MTI3LjAuMC4xMCwGCWCGSAGG+EIBDQQfFh1PcGVuU1NMIEdlbmVyYXRlZCBDZXJ0
+aWZpY2F0ZTANBgkqhkiG9w0BAQsFAAOCAQEAJHG/5WOmpO7wg3BtTt4b0DoqDJjh
+eQb9Woq5xbvliZ1RCp8E6m6BmOr66i4qu5r+31DEeAeQ2M9pG2nJKoayCVi2ygaQ
+RAulxIH7o5+JUcZtX6FbRBsS7Go+SLmtkkJ89YVSIF40+2CAQs7loqQjHNeo9/iO
+rVKt1Fa6rQhXmv4ItVOwRaMBvXRVw4gc3ObmH0ZBYZrvsE7uQkKX5f6sVKXOX3mm
+ofyB+22QMYmx3XvEEQm8ELnjIr5Q8LxqQxHqjLFjyrcrXYVi4+3/PfjIdRr5+qes
+H8JWJlAbF/SNncdXRb1jtkdxit56Qo7/Mz/c4Yuh1WLiYcQGJeBpr53dmg==
 -----END CERTIFICATE-----
diff --git a/arbnode/dataposter/testdata/localhost.key b/arbnode/dataposter/testdata/localhost.key
index aad9b40b3d..f56aef1e77 100644
--- a/arbnode/dataposter/testdata/localhost.key
+++ b/arbnode/dataposter/testdata/localhost.key
@@ -1,28 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC4O18GiIeJdhaf
-GjHzTHU0EjDzEdM6Z4nFU5/3oqM1rKpQCmsZkDNz8SdKFVlt4ifPaeK7+ZvlIyug
-677FEDs5fIrIMhgkzJ5C7cRZcmpZQzUQ2sEXLkz7jSPTZHSZvmc+x6KC8xXgQ3kt
-d4kTxF69U/+Gn/TIzsahb28OcQWPZOLXNoT6eqtNPePID1iiAfTM+LYaAdh5dq0A
-WF/1oY0p63vaPaqMgTtFwLBtJrLAbNbz2vf2hKewuXA2NBwrjNUSI4V50aW/JQvV
-UGgvhaMw335pttxBlaS5sj7OfdFDrVSXU1HekNEwE+ne34wkVCddg3p3UH9rjBVf
-dLumI9M1AgMBAAECggEAHuc8oyKrQ5xmooUZHGP2pAeqJNfYXAtqoYpLwtUJ9hKy
-1e7NdNIKw3fP/J4UrHk7btAm65us8hSCeMGatEErAhNZT0gR4zhcksMCBPQLkVIT
-+HINYjdOzAJqoEbRRUnaVT5VDQy8HmyLCtyqhoGR18XbjshNnhKLYKCJ2z0Lrvf2
-3rU7bbt7/rvLitVhxVL8SIe2jWSfIgcEmEAZMigB9WAnUyQ/tAfbPy1I764LLfzD
-nLXn7E2OH7GrxkLjOsH9kfERlur7V7IhC9NE/wI0q+rnILRa7Q3+ifRu8qla3bo1
-iyHl1ZmsYJ8Jnzbu9exzZaQmk42OoFPcMFm0mRe+2QKBgQDvRv0Q5JhBuVurkU98
-lzATwEO0uYmeWDMnHzrFSWAKr/x4LNQ9ytSCfe1aLxgOkZq6dQ3TyZiCYzpmwGz9
-K7/gghxmsVDKeCqiGVZOgFAWy7AhQyF6zM60oqqwSvJHhmGTsA/B5LPUiYe9lITW
-ZSLVYkOzha7Coa++U8vPzI5VaQKBgQDFG4reFT79j8RKEm9jie6PdRdYMzOSDWty
-Gjj5N9Jnlp1k/6RzCxjmp7w7yIorq/7fWZsQtt0UqgayOn25+I8dZeGC0BradUSB
-tZbGElxPsF8Jg00ZvvK3G5mpZYDrJCud8Q05EaUZPXv9GuZhozEsTQgylVecVzsN
-wyEK8VuZ7QKBgQChx9adUGIdtgzkILiknbh08j8U94mz1SCo5/WdpLHaKAlE29KZ
-AQXUQP51Rng2iX4bab9yndCPADZheON3/debHX3EdUkRzFPPC+CN7TW5Y/jvVGtT
-kxyDh6Ru1A2iDJr290iAKXjpUB/GL5/tMa5upiTuQYnasOWZgyC/nCf0WQKBgEwn
-pRLDMLA1IMjhsInL3BEvU1KvjahLaQ0P1p1rlO6TAcLpBrewPPG5MwACLmhLLtFK
-xJ/Dl02Jl8a61KLKxzi7iVLKZuWq00ouR8/FfkcHxOBfC6X74bkff9I0NogjVHrU
-jKBVEe3blJEpGIP20mPka1tn2g68oUNi9dxNfm/NAoGAWj/Q0pgnNq0MQ8Lj6m99
-1baaXSo8biks3E3A3cqhHQm/j3SRnkf0lueQW8+r9yR9IWdYFXz5Waq13qK+lopE
-KDmww0xr8dyMUYTP1vde7np2XKa/OX3iejDzbI3RcZN/DEV+dCBY8pqHHfaAaESu
-fwBWvfD8wtwCZzB3lOZEi80=
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDK4BRVZ0nU98/f
+l+QC4fF60oNtlMPCC/2R6GZoWz7VyhrrXBuol+F9vboAePxLgxeIr/pwHAbFWlW2
+ueAsN9dorC2waf5PDhfOE0gI6w7LysTkO5n7oMFf1KYPSpPJ15WxlobZR8qWeroR
+we7z44tQ2F+es+HaqBrrk7jm0GS9AqaledN/ay9SP4CBu029F6nWDnK+VpNWuoN4
+A/pnwGFWrxDf0ftN7BxnxzzdsWs64+kYfz91Mojce2UKGuDTuk/oqOnHhX34bFDc
+/e9KGAQqP1I+RuCJmQXW5b55+3WgpvT3u3Mp7478C+AK8GthPjja7go48nHp3uby
+drNpTw+bAgMBAAECggEANE2Q8HOwlTdOYFbIcfXOS9v6BkZUMbLlrLg9rqnXiUaR
+qhwVBWIiwEgpq/WFFfK2HodACacwF7EyZ+mD4eKDpni9Tr4E0lzPxlEyQRpYtjGQ
+kUbMbBMFx68LIOYZM/Bgp2gnW90mXaVGU02sTTRctnsSK9g0Yir0xcdP5DHVxuRy
+cReMIDjHu7/PN5X12oHpBxT1w7TKYZk3M2ZbmRcGfRSv1UIg06hXjxY4Tonqxv5b
+Yv/R/r+RYsHE6cO3hLV7FE/ypaRFGt/qcHhqwmHKlpc+8/FNEpb5truXCbf5LhjM
+YD2eMOpiBaiyufs+2BpUy/iDKToYz+fdusT5N3FgAQKBgQDuemOauY/ytbETUabB
+Vt11fCvXvsx4L+45vqtVcRWl6jcy73rMnyA80D/ndzyxkuw2NRAllIUvsdVG26vM
+8nWAxrsY7rrZ4kdRAAKAPYmTtT2O4mvhvJOYHA/ueEUamrKqZMgyLik1Wl1y2mt2
+Iak0zNB0GWoHsgDF20TTbxKTkwKBgQDZyAa/r3qhokKfvg/7LhwXH7vdiJd35zp1
+K1KZVeZf97FeReL4DLfTHZ92yFyVhWepp97Icd2WtQZ8jVVcesTP9C+mVoFEGXZf
+nWx5y2WD92dBP/kKYNayXuBFQnRfS4AC7ALK8fKrU/Fzc7OctnkvHHWZfaKQ2sQ5
+xydj6Rso2QKBgBpgvT2zAsIU6MY7RNej1REWr/7IIvO0UYRfm7HytTNJ6dsfdBTI
+ERfI7RicLsFxf+ErE2Mkv2qcH/wbdjBQLUEWOkGyvkY1ajACcURgCiSlam6wisBI
+TIcJq5V0BijALbz9MsuiIXq+SRHYKQTDCmVFtlTxLrI1NTKtYzqD0akzAoGAB5fW
+zGYk42/R3Nn2mq5f4lqD5VR224JfYmhxR9Fb5+qt73iGUlm3KxA0WCLiP4BYPe0R
+cnGt5SxInp0a5c+N/yYnZyhK94Hfw7OsbY6u6mv82KSPXVJFChEOxrtrbUsnmnJ6
+InNPH7QcjgbxszwVe5QFcaWUvnIyN0V/VRdyj/kCgYEA0kPCIPR7t7OFEnQsw50W
+AclrTlGRB0TzmCYZN4DTKC+1ZAV80XQUR4umJpHeyArdRZpFv+HBLF7fHsBnkmiU
+ixBdbWgW4mxjAhyZkLMjcCkoiLmRPDUvELyFs4xpM+IEKoAk60PPbGi4CeIMHb5k
+E47NZaw1bdG1tv2ya1FlQ/k=
 -----END PRIVATE KEY-----
diff --git a/arbnode/dataposter/testdata/regenerate-certs.sh b/arbnode/dataposter/testdata/regenerate-certs.sh
new file mode 100755
index 0000000000..6bcbd27b8e
--- /dev/null
+++ b/arbnode/dataposter/testdata/regenerate-certs.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -eu
+cd "$(dirname "$0")"
+for name in localhost client; do
+    openssl genrsa -out "$name.key" 2048
+    csr="$(openssl req -new -key "$name.key" -config "$name.cnf" -batch)"
+    openssl x509 -req -signkey "$name.key" -out "$name.crt" -days 36500 -extensions req_ext -extfile "$name.cnf" <<< "$csr"
+done
diff --git a/arbnode/maintenance.go b/arbnode/maintenance.go
index 53d038a0f9..7397229c2e 100644
--- a/arbnode/maintenance.go
+++ b/arbnode/maintenance.go
@@ -101,7 +101,7 @@ func NewMaintenanceRunner(config MaintenanceConfigFetcher, seqCoordinator *SeqCo
 	if seqCoordinator != nil {
 		c := func() *redislock.SimpleCfg { return &cfg.Lock }
 		r := func() bool { return true } // always ready to lock
-		rl, err := redislock.NewSimple(seqCoordinator.Client, c, r)
+		rl, err := redislock.NewSimple(seqCoordinator.RedisCoordinator().Client, c, r)
 		if err != nil {
 			return nil, fmt.Errorf("creating new simple redis lock: %w", err)
 		}
diff --git a/arbnode/seq_coordinator.go b/arbnode/seq_coordinator.go
index d22b4f7491..5987801d5f 100644
--- a/arbnode/seq_coordinator.go
+++ b/arbnode/seq_coordinator.go
@@ -37,7 +37,10 @@ var (
 type SeqCoordinator struct {
 	stopwaiter.StopWaiter
 
-	redisutil.RedisCoordinator
+	redisCoordinatorMutex sync.RWMutex
+	redisCoordinator      redisutil.RedisCoordinator
+	prevRedisCoordinator  *redisutil.RedisCoordinator
+	prevRedisMessageCount arbutil.MessageIndex
 
 	sync             *SyncMonitor
 	streamer         *TransactionStreamer
@@ -61,6 +64,7 @@ type SeqCoordinatorConfig struct {
 	Enable                bool          `koanf:"enable"`
 	ChosenHealthcheckAddr string        `koanf:"chosen-healthcheck-addr"`
 	RedisUrl              string        `koanf:"redis-url"`
+	NewRedisUrl           string        `koanf:"new-redis-url"`
 	LockoutDuration       time.Duration `koanf:"lockout-duration"`
 	LockoutSpare          time.Duration `koanf:"lockout-spare"`
 	SeqNumDuration        time.Duration `koanf:"seq-num-duration"`
@@ -86,6 +90,7 @@ func (c *SeqCoordinatorConfig) Url() string {
 func SeqCoordinatorConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Bool(prefix+".enable", DefaultSeqCoordinatorConfig.Enable, "enable sequence coordinator")
 	f.String(prefix+".redis-url", DefaultSeqCoordinatorConfig.RedisUrl, "the Redis URL to coordinate via")
+	f.String(prefix+".new-redis-url", DefaultSeqCoordinatorConfig.NewRedisUrl, "switch to the new Redis URL to coordinate via")
 	f.String(prefix+".chosen-healthcheck-addr", DefaultSeqCoordinatorConfig.ChosenHealthcheckAddr, "if non-empty, launch an HTTP service binding to this address that returns status code 200 when chosen and 503 otherwise")
 	f.Duration(prefix+".lockout-duration", DefaultSeqCoordinatorConfig.LockoutDuration, "")
 	f.Duration(prefix+".lockout-spare", DefaultSeqCoordinatorConfig.LockoutSpare, "")
@@ -105,6 +110,7 @@ var DefaultSeqCoordinatorConfig = SeqCoordinatorConfig{
 	Enable:                false,
 	ChosenHealthcheckAddr: "",
 	RedisUrl:              "",
+	NewRedisUrl:           "",
 	LockoutDuration:       time.Minute,
 	LockoutSpare:          30 * time.Second,
 	SeqNumDuration:        10 * 24 * time.Hour,
@@ -122,6 +128,7 @@ var DefaultSeqCoordinatorConfig = SeqCoordinatorConfig{
 var TestSeqCoordinatorConfig = SeqCoordinatorConfig{
 	Enable:              false,
 	RedisUrl:            "",
+	NewRedisUrl:         "",
 	LockoutDuration:     time.Second * 2,
 	LockoutSpare:        time.Millisecond * 10,
 	SeqNumDuration:      time.Minute * 10,
@@ -153,7 +160,7 @@ func NewSeqCoordinator(
 		return nil, err
 	}
 	coordinator := &SeqCoordinator{
-		RedisCoordinator: *redisCoordinator,
+		redisCoordinator: *redisCoordinator,
 		sync:             sync,
 		streamer:         streamer,
 		sequencer:        sequencer,
@@ -174,6 +181,19 @@ func (c *SeqCoordinator) SetDelayedSequencer(delayedSequencer *DelayedSequencer)
 	c.delayedSequencer = delayedSequencer
 }
 
+func (c *SeqCoordinator) RedisCoordinator() *redisutil.RedisCoordinator {
+	c.redisCoordinatorMutex.RLock()
+	defer c.redisCoordinatorMutex.RUnlock()
+	return &c.redisCoordinator
+}
+
+func (c *SeqCoordinator) setRedisCoordinator(redisCoordinator *redisutil.RedisCoordinator) {
+	c.redisCoordinatorMutex.Lock()
+	defer c.redisCoordinatorMutex.Unlock()
+	c.prevRedisCoordinator = &c.redisCoordinator
+	c.redisCoordinator = *redisCoordinator
+}
+
 func StandaloneSeqCoordinatorInvalidateMsgIndex(ctx context.Context, redisClient redis.UniversalClient, keyConfig string, msgIndex arbutil.MessageIndex) error {
 	signerConfig := signature.EmptySimpleHmacConfig
 	if keyConfig == "" {
@@ -276,7 +296,7 @@ func (c *SeqCoordinator) acquireLockoutAndWriteMessage(ctx context.Context, msgC
 	defer c.wantsLockoutMutex.Unlock()
 	setWantsLockout := c.avoidLockout <= 0
 	lockoutUntil := time.Now().Add(c.config.LockoutDuration)
-	err = c.Client.Watch(ctx, func(tx *redis.Tx) error {
+	err = c.RedisCoordinator().Client.Watch(ctx, func(tx *redis.Tx) error {
 		current, err := tx.Get(ctx, redisutil.CHOSENSEQ_KEY).Result()
 		var wasEmpty bool
 		if errors.Is(err, redis.Nil) {
@@ -345,7 +365,7 @@ func (c *SeqCoordinator) acquireLockoutAndWriteMessage(ctx context.Context, msgC
 }
 
 func (c *SeqCoordinator) getRemoteFinalizedMsgCount(ctx context.Context) (arbutil.MessageIndex, error) {
-	resStr, err := c.Client.Get(ctx, redisutil.FINALIZED_MSG_COUNT_KEY).Result()
+	resStr, err := c.RedisCoordinator().Client.Get(ctx, redisutil.FINALIZED_MSG_COUNT_KEY).Result()
 	if err != nil {
 		return 0, err
 	}
@@ -364,23 +384,23 @@ func (c *SeqCoordinator) getRemoteMsgCountImpl(ctx context.Context, r redis.Cmda
 }
 
 func (c *SeqCoordinator) GetRemoteMsgCount() (arbutil.MessageIndex, error) {
-	return c.getRemoteMsgCountImpl(c.GetContext(), c.Client)
+	return c.getRemoteMsgCountImpl(c.GetContext(), c.RedisCoordinator().Client)
 }
 
-func (c *SeqCoordinator) wantsLockoutUpdate(ctx context.Context) error {
+func (c *SeqCoordinator) wantsLockoutUpdate(ctx context.Context, client redis.UniversalClient) error {
 	c.wantsLockoutMutex.Lock()
 	defer c.wantsLockoutMutex.Unlock()
-	return c.wantsLockoutUpdateWithMutex(ctx)
+	return c.wantsLockoutUpdateWithMutex(ctx, client)
 }
 
 // Requires the caller hold the wantsLockoutMutex
-func (c *SeqCoordinator) wantsLockoutUpdateWithMutex(ctx context.Context) error {
+func (c *SeqCoordinator) wantsLockoutUpdateWithMutex(ctx context.Context, client redis.UniversalClient) error {
 	if c.avoidLockout > 0 {
 		return nil
 	}
 	myWantsLockoutKey := redisutil.WantsLockoutKeyFor(c.config.Url())
 	wantsLockoutUntil := time.Now().Add(c.config.LockoutDuration)
-	pipe := c.Client.TxPipeline()
+	pipe := client.TxPipeline()
 	initialDuration := c.config.LockoutDuration
 	if initialDuration < 2*time.Second {
 		initialDuration = 2 * time.Second
@@ -398,7 +418,7 @@ func (c *SeqCoordinator) wantsLockoutUpdateWithMutex(ctx context.Context) error
 func (c *SeqCoordinator) chosenOneRelease(ctx context.Context) error {
 	atomicTimeWrite(&c.lockoutUntil, time.Time{})
 	isActiveSequencer.Update(0)
-	releaseErr := c.Client.Watch(ctx, func(tx *redis.Tx) error {
+	releaseErr := c.RedisCoordinator().Client.Watch(ctx, func(tx *redis.Tx) error {
 		current, err := tx.Get(ctx, redisutil.CHOSENSEQ_KEY).Result()
 		if errors.Is(err, redis.Nil) {
 			return nil
@@ -421,7 +441,7 @@ func (c *SeqCoordinator) chosenOneRelease(ctx context.Context) error {
 		return nil
 	}
 	// got error - was it still released?
-	current, readErr := c.Client.Get(ctx, redisutil.CHOSENSEQ_KEY).Result()
+	current, readErr := c.RedisCoordinator().Client.Get(ctx, redisutil.CHOSENSEQ_KEY).Result()
 	if errors.Is(readErr, redis.Nil) {
 		return nil
 	}
@@ -438,10 +458,10 @@ func (c *SeqCoordinator) wantsLockoutRelease(ctx context.Context) error {
 		return nil
 	}
 	myWantsLockoutKey := redisutil.WantsLockoutKeyFor(c.config.Url())
-	releaseErr := c.Client.Del(ctx, myWantsLockoutKey).Err()
+	releaseErr := c.RedisCoordinator().Client.Del(ctx, myWantsLockoutKey).Err()
 	if releaseErr != nil {
 		// got error - was it still deleted?
-		readErr := c.Client.Get(ctx, myWantsLockoutKey).Err()
+		readErr := c.RedisCoordinator().Client.Get(ctx, myWantsLockoutKey).Err()
 		if !errors.Is(readErr, redis.Nil) {
 			return releaseErr
 		}
@@ -525,7 +545,7 @@ func (c *SeqCoordinator) deleteFinalizedMsgsFromRedis(ctx context.Context, final
 			// In non-init cases it doesn't matter how we delete as we always try to delete from prevFinalized to finalized
 			batchDeleteCount := 1000
 			for i := len(keys); i > 0; i -= batchDeleteCount {
-				if err := c.Client.Del(ctx, keys[max(0, i-batchDeleteCount):i]...).Err(); err != nil {
+				if err := c.RedisCoordinator().Client.Del(ctx, keys[max(0, i-batchDeleteCount):i]...).Err(); err != nil {
 					return fmt.Errorf("error deleting finalized messages and their signatures from redis: %w", err)
 				}
 			}
@@ -534,7 +554,7 @@ func (c *SeqCoordinator) deleteFinalizedMsgsFromRedis(ctx context.Context, final
 		if err != nil {
 			return err
 		}
-		if err = c.Client.Set(ctx, redisutil.FINALIZED_MSG_COUNT_KEY, finalizedBytes, c.config.SeqNumDuration).Err(); err != nil {
+		if err = c.RedisCoordinator().Client.Set(ctx, redisutil.FINALIZED_MSG_COUNT_KEY, finalizedBytes, c.config.SeqNumDuration).Err(); err != nil {
 			return fmt.Errorf("couldn't set %s key to current finalizedMsgCount in redis: %w", redisutil.FINALIZED_MSG_COUNT_KEY, err)
 		}
 		return nil
@@ -543,7 +563,7 @@ func (c *SeqCoordinator) deleteFinalizedMsgsFromRedis(ctx context.Context, final
 	if errors.Is(err, redis.Nil) {
 		var keys []string
 		for msg := finalized - 1; msg > 0; msg-- {
-			exists, err := c.Client.Exists(ctx, redisutil.MessageKeyFor(msg), redisutil.MessageSigKeyFor(msg)).Result()
+			exists, err := c.RedisCoordinator().Client.Exists(ctx, redisutil.MessageKeyFor(msg), redisutil.MessageSigKeyFor(msg)).Result()
 			if err != nil {
 				// If there is an error deleting finalized messages during init, we retry later either from this sequencer or from another
 				return err
@@ -558,7 +578,7 @@ func (c *SeqCoordinator) deleteFinalizedMsgsFromRedis(ctx context.Context, final
 	} else if err != nil {
 		return fmt.Errorf("error getting finalizedMsgCount value from redis: %w", err)
 	}
-	remoteMsgCount, err := c.getRemoteMsgCountImpl(ctx, c.Client)
+	remoteMsgCount, err := c.getRemoteMsgCountImpl(ctx, c.RedisCoordinator().Client)
 	if err != nil {
 		return fmt.Errorf("cannot get remote message count: %w", err)
 	}
@@ -574,7 +594,7 @@ func (c *SeqCoordinator) deleteFinalizedMsgsFromRedis(ctx context.Context, final
 }
 
 func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
-	chosenSeq, err := c.RecommendSequencerWantingLockout(ctx)
+	chosenSeq, err := c.RedisCoordinator().RecommendSequencerWantingLockout(ctx)
 	if err != nil {
 		log.Warn("coordinator failed finding sequencer wanting lockout", "err", err)
 		return c.retryAfterRedisError()
@@ -603,6 +623,15 @@ func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
 		log.Error("cannot read message count", "err", err)
 		return c.config.UpdateInterval
 	}
+	// Cache the previous redis coordinator's message count
+	if c.prevRedisCoordinator != nil && c.prevRedisMessageCount == 0 {
+		prevRemoteMsgCount, err := c.getRemoteMsgCountImpl(ctx, c.prevRedisCoordinator.Client)
+		if err != nil {
+			log.Warn("cannot get remote message count", "err", err)
+			return c.retryAfterRedisError()
+		}
+		c.prevRedisMessageCount = prevRemoteMsgCount
+	}
 	remoteFinalizedMsgCount, err := c.getRemoteFinalizedMsgCount(ctx)
 	if err != nil {
 		loglevel := log.Error
@@ -617,12 +646,22 @@ func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
 		return c.retryAfterRedisError()
 	}
 	readUntil := min(localMsgCount+c.config.MsgPerPoll, remoteMsgCount)
+	client := c.RedisCoordinator().Client
+	// If we have a previous redis coordinator,
+	// we can read from it until the local message count catches up to the prev coordinator's message count
+	if c.prevRedisMessageCount > localMsgCount {
+		readUntil = min(readUntil, c.prevRedisMessageCount)
+		client = c.prevRedisCoordinator.Client
+	}
+	if c.prevRedisMessageCount != 0 && localMsgCount >= c.prevRedisMessageCount {
+		log.Info("coordinator caught up to prev redis coordinator", "msgcount", localMsgCount, "prevMsgCount", c.prevRedisMessageCount)
+	}
 	var messages []arbostypes.MessageWithMetadata
 	msgToRead := localMsgCount
 	var msgReadErr error
 	for msgToRead < readUntil && localMsgCount >= remoteFinalizedMsgCount {
 		var resString string
-		resString, msgReadErr = c.Client.Get(ctx, redisutil.MessageKeyFor(msgToRead)).Result()
+		resString, msgReadErr = client.Get(ctx, redisutil.MessageKeyFor(msgToRead)).Result()
 		if msgReadErr != nil {
 			log.Warn("coordinator failed reading message", "pos", msgToRead, "err", msgReadErr)
 			break
@@ -631,7 +670,7 @@ func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
 		var sigString string
 		var sigBytes []byte
 		sigSeparateKey := true
-		sigString, msgReadErr = c.Client.Get(ctx, redisutil.MessageSigKeyFor(msgToRead)).Result()
+		sigString, msgReadErr = client.Get(ctx, redisutil.MessageSigKeyFor(msgToRead)).Result()
 		if errors.Is(msgReadErr, redis.Nil) {
 			// no separate signature. Try reading old-style sig
 			if len(rsBytes) < 32 {
@@ -722,7 +761,7 @@ func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
 				// this could be just new messages we didn't get yet - even then, we should retry soon
 				log.Info("sequencer failed to become chosen", "err", err, "msgcount", localMsgCount)
 				// make sure we're marked as wanting the lockout
-				if err := c.wantsLockoutUpdate(ctx); err != nil {
+				if err := c.wantsLockoutUpdate(ctx, c.RedisCoordinator().Client); err != nil {
 					log.Warn("failed to update wants lockout key", "err", err)
 				}
 				c.prevChosenSequencer = ""
@@ -750,7 +789,7 @@ func (c *SeqCoordinator) update(ctx context.Context) time.Duration {
 	// update wanting the lockout
 	var wantsLockoutErr error
 	if synced && !c.AvoidingLockout() {
-		wantsLockoutErr = c.wantsLockoutUpdate(ctx)
+		wantsLockoutErr = c.wantsLockoutUpdate(ctx, c.RedisCoordinator().Client)
 	} else {
 		wantsLockoutErr = c.wantsLockoutRelease(ctx)
 	}
@@ -817,12 +856,59 @@ func (c *SeqCoordinator) launchHealthcheckServer(ctx context.Context) {
 
 func (c *SeqCoordinator) Start(ctxIn context.Context) {
 	c.StopWaiter.Start(ctxIn, c)
-	c.CallIteratively(c.update)
+	var newRedisCoordinator *redisutil.RedisCoordinator
+	if c.config.NewRedisUrl != "" {
+		var err error
+		newRedisCoordinator, err = redisutil.NewRedisCoordinator(c.config.NewRedisUrl)
+		if err != nil {
+			log.Warn("failed to create new redis coordinator", "err",
+				err, "newRedisUrl", c.config.NewRedisUrl)
+		}
+	}
+	c.CallIteratively(func(ctx context.Context) time.Duration { return c.chooseRedisAndUpdate(ctx, newRedisCoordinator) })
 	if c.config.ChosenHealthcheckAddr != "" {
 		c.StopWaiter.LaunchThread(c.launchHealthcheckServer)
 	}
 }
 
+func (c *SeqCoordinator) chooseRedisAndUpdate(ctx context.Context, newRedisCoordinator *redisutil.RedisCoordinator) time.Duration {
+	// If we have a new redis coordinator, and we haven't switched to it yet, try to switch.
+	if c.config.NewRedisUrl != "" && c.prevRedisCoordinator == nil {
+		// If we fail to try to switch, we'll retry soon.
+		if err := c.trySwitchingRedis(ctx, newRedisCoordinator); err != nil {
+			log.Warn("error while trying to switch redis coordinator", "err", err)
+			return c.retryAfterRedisError()
+		}
+	}
+	return c.update(ctx)
+}
+
+func (c *SeqCoordinator) trySwitchingRedis(ctx context.Context, newRedisCoordinator *redisutil.RedisCoordinator) error {
+	err := c.wantsLockoutUpdate(ctx, newRedisCoordinator.Client)
+	if err != nil {
+		return err
+	}
+	current, err := c.RedisCoordinator().Client.Get(ctx, redisutil.CHOSENSEQ_KEY).Result()
+	var wasEmpty bool
+	if errors.Is(err, redis.Nil) {
+		wasEmpty = true
+		err = nil
+	}
+	if err != nil {
+		log.Warn("failed to get current chosen sequencer", "err", err)
+		return err
+	}
+	// If the chosen key is set to switch, we need to switch to the new redis coordinator.
+	if !wasEmpty && (current == redisutil.SWITCHED_REDIS) {
+		err = c.wantsLockoutUpdate(ctx, c.RedisCoordinator().Client)
+		if err != nil {
+			return err
+		}
+		c.setRedisCoordinator(newRedisCoordinator)
+	}
+	return nil
+}
+
 // Calls check() every c.config.RetryInterval until it returns true, or the context times out.
 func (c *SeqCoordinator) waitFor(ctx context.Context, check func() bool) bool {
 	for {
@@ -872,7 +958,7 @@ func (c *SeqCoordinator) StopAndWait() {
 			time.Sleep(c.retryAfterRedisError())
 		}
 	}
-	_ = c.Client.Close()
+	_ = c.RedisCoordinator().Client.Close()
 }
 
 func (c *SeqCoordinator) CurrentlyChosen() bool {
@@ -914,7 +1000,7 @@ func (c *SeqCoordinator) TryToHandoffChosenOne(ctx context.Context) bool {
 			return !c.CurrentlyChosen()
 		})
 		if success {
-			wantsLockout, err := c.RecommendSequencerWantingLockout(ctx)
+			wantsLockout, err := c.RedisCoordinator().RecommendSequencerWantingLockout(ctx)
 			if err == nil {
 				log.Info("released chosen one status; a new sequencer hopefully wants to acquire it", "delay", c.config.SafeShutdownDelay, "wantsLockout", wantsLockout)
 			} else {
@@ -936,7 +1022,7 @@ func (c *SeqCoordinator) SeekLockout(ctx context.Context) {
 	log.Info("seeking lockout", "myUrl", c.config.Url())
 	if c.sequencer.Synced() {
 		// Even if this errors we still internally marked ourselves as wanting the lockout
-		err := c.wantsLockoutUpdateWithMutex(ctx)
+		err := c.wantsLockoutUpdateWithMutex(ctx, c.RedisCoordinator().Client)
 		if err != nil {
 			log.Warn("failed to set wants lockout key in redis after seeking lockout again", "err", err)
 		}
diff --git a/arbnode/seq_coordinator_test.go b/arbnode/seq_coordinator_test.go
index 6498543f3a..3f35011c20 100644
--- a/arbnode/seq_coordinator_test.go
+++ b/arbnode/seq_coordinator_test.go
@@ -125,7 +125,7 @@ func TestRedisSeqCoordinatorAtomic(t *testing.T) {
 		redisCoordinator, err := redisutil.NewRedisCoordinator(config.RedisUrl)
 		Require(t, err)
 		coordinator := &SeqCoordinator{
-			RedisCoordinator: *redisCoordinator,
+			redisCoordinator: *redisCoordinator,
 			config:           config,
 			signer:           nullSigner,
 		}
@@ -181,7 +181,7 @@ func TestSeqCoordinatorDeletesFinalizedMessages(t *testing.T) {
 	redisCoordinator, err := redisutil.NewRedisCoordinator(config.RedisUrl)
 	Require(t, err)
 	coordinator := &SeqCoordinator{
-		RedisCoordinator: *redisCoordinator,
+		redisCoordinator: *redisCoordinator,
 		config:           config,
 		signer:           nullSigner,
 	}
@@ -191,18 +191,18 @@ func TestSeqCoordinatorDeletesFinalizedMessages(t *testing.T) {
 	msgBytes, err := coordinator.msgCountToSignedBytes(0)
 	Require(t, err)
 	for i := arbutil.MessageIndex(1); i <= 10; i++ {
-		err = coordinator.Client.Set(ctx, redisutil.MessageKeyFor(i), msgBytes, time.Hour).Err()
+		err = coordinator.RedisCoordinator().Client.Set(ctx, redisutil.MessageKeyFor(i), msgBytes, time.Hour).Err()
 		Require(t, err)
-		err = coordinator.Client.Set(ctx, redisutil.MessageSigKeyFor(i), msgBytes, time.Hour).Err()
+		err = coordinator.RedisCoordinator().Client.Set(ctx, redisutil.MessageSigKeyFor(i), msgBytes, time.Hour).Err()
 		Require(t, err)
 		keys = append(keys, redisutil.MessageKeyFor(i), redisutil.MessageSigKeyFor(i))
 	}
 	// Set msgCount key
 	msgCountBytes, err := coordinator.msgCountToSignedBytes(11)
 	Require(t, err)
-	err = coordinator.Client.Set(ctx, redisutil.MSG_COUNT_KEY, msgCountBytes, time.Hour).Err()
+	err = coordinator.RedisCoordinator().Client.Set(ctx, redisutil.MSG_COUNT_KEY, msgCountBytes, time.Hour).Err()
 	Require(t, err)
-	exists, err := coordinator.Client.Exists(ctx, keys...).Result()
+	exists, err := coordinator.RedisCoordinator().Client.Exists(ctx, keys...).Result()
 	Require(t, err)
 	if exists != 20 {
 		t.Fatal("couldn't find all messages and signatures in redis")
@@ -213,7 +213,7 @@ func TestSeqCoordinatorDeletesFinalizedMessages(t *testing.T) {
 	Require(t, err)
 
 	// Check if messages and signatures were deleted successfully
-	exists, err = coordinator.Client.Exists(ctx, keys[:8]...).Result()
+	exists, err = coordinator.RedisCoordinator().Client.Exists(ctx, keys[:8]...).Result()
 	Require(t, err)
 	if exists != 0 {
 		t.Fatal("finalized messages and signatures in range 1 to 4 were not deleted")
@@ -229,7 +229,7 @@ func TestSeqCoordinatorDeletesFinalizedMessages(t *testing.T) {
 	// Try deleting finalized messages when theres already a finalizedMsgCount
 	err = coordinator.deleteFinalizedMsgsFromRedis(ctx, 7)
 	Require(t, err)
-	exists, err = coordinator.Client.Exists(ctx, keys[8:12]...).Result()
+	exists, err = coordinator.RedisCoordinator().Client.Exists(ctx, keys[8:12]...).Result()
 	Require(t, err)
 	if exists != 0 {
 		t.Fatal("finalized messages and signatures in range 5 to 6 were not deleted")
@@ -241,7 +241,7 @@ func TestSeqCoordinatorDeletesFinalizedMessages(t *testing.T) {
 	}
 
 	// Check that non-finalized messages are still available in redis
-	exists, err = coordinator.Client.Exists(ctx, keys[12:]...).Result()
+	exists, err = coordinator.RedisCoordinator().Client.Exists(ctx, keys[12:]...).Result()
 	Require(t, err)
 	if exists != 8 {
 		t.Fatal("non-finalized messages and signatures in range 7 to 10 are not fully available")
diff --git a/scripts/check-build.sh b/scripts/check-build.sh
new file mode 100755
index 0000000000..d654405c49
--- /dev/null
+++ b/scripts/check-build.sh
@@ -0,0 +1,138 @@
+#!/bin/bash
+# This script checks the prerequisites for building Arbitrum Nitro locally.
+
+# Color codes
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Documentation link for installation instructions
+INSTALLATION_DOCS_URL="Refer to https://docs.arbitrum.io/run-arbitrum-node/nitro/build-nitro-locally for installation."
+
+# Function to check if a command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+EXIT_CODE=0
+
+# Detect operating system
+OS=$(uname -s)
+echo -e "${BLUE}Detected OS: $OS${NC}"
+echo -e "${BLUE}Checking prerequisites for building Nitro locally...${NC}"
+
+# Step 1: Check Docker Installation
+if command_exists docker; then
+    echo -e "${GREEN}Docker is installed.${NC}"
+else
+    echo -e "${RED}Docker is not installed.${NC}"
+    EXIT_CODE=1
+fi
+
+# Step 2: Check if Docker service is running
+if [[ "$OS" == "Linux" ]] && ! sudo service docker status >/dev/null; then
+    echo -e "${YELLOW}Docker service is not running on Linux. Start it with: sudo service docker start${NC}"
+    EXIT_CODE=1
+elif [[ "$OS" == "Darwin" ]] && ! docker info >/dev/null 2>&1; then
+    echo -e "${YELLOW}Docker service is not running on macOS. Ensure Docker Desktop is started.${NC}"
+   EXIT_CODE=1
+else
+    echo -e "${GREEN}Docker service is running.${NC}"
+fi
+
+# Step 3: Check the version tag
+VERSION_TAG=$(git tag --points-at HEAD | sed '/-/!s/$/_/' | sort -rV | sed 's/_$//' | head -n 1 | grep ^ || git show -s --pretty=%D | sed 's/, /\n/g' | grep -v '^origin/' | grep -v '^grafted\|HEAD\|master\|main$' || echo "dev")
+echo -e "${YELLOW}You are on the version tag: $VERSION_TAG${NC}"
+
+# Check if submodules are properly initialized and updated
+if git submodule status | grep -qE '^-|\+'; then
+    echo -e "${YELLOW}Submodules are not properly initialized or updated. Run: git submodule update --init --recursive --force${NC}"
+    EXIT_CODE=1
+else
+    echo -e "${GREEN}All submodules are properly initialized and up to date.${NC}"
+fi
+
+# Step 4: Check if Nitro Docker Image is built
+if docker images | grep -q "nitro-node"; then
+    echo -e "${GREEN}Nitro Docker image is built.${NC}"
+else
+    echo -e "${YELLOW}Nitro Docker image is not built. Build it using: docker build . --tag nitro-node${NC}"
+fi
+
+# Step 5: Check prerequisites for building binaries
+echo -e "${BLUE}Checking prerequisites for building Nitro's binaries...${NC}"
+if [[ "$OS" == "Linux" ]]; then
+    prerequisites=(git curl make cmake npm golang clang make gotestsum wasm2wat wasm-ld python3 yarn)
+else
+    prerequisites=(git curl make cmake npm go golangci-lint wasm2wat clang wasm-ld gotestsum yarn)
+fi
+
+for pkg in "${prerequisites[@]}"; do
+    EXISTS=$(command_exists "$pkg")
+    [[ "$pkg" == "make" ]] && pkg="build-essential"
+    [[ "$pkg" == "wasm2wat" ]] && pkg="wabt"
+    [[ "$pkg" == "clang" ]] && pkg="llvm"
+    [[ "$pkg" == "wasm-ld" ]] && pkg="lld"
+    if $EXISTS; then
+        # There is no way to check for wabt / llvm directly, since they install multiple tools
+        # So instead, we check for wasm2wat and clang, which are part of wabt and llvm respectively
+        # and if they are installed, we assume wabt / llvm is installed else we ask the user to install wabt / llvm
+
+        echo -e "${GREEN}$pkg is installed.${NC}"
+    else
+        echo -e "${RED}$pkg is not installed. Please install $pkg.${NC}"
+        EXIT_CODE=1
+    fi
+done
+
+# Step 6: Check Node.js version
+if command_exists node && node -v | grep -q "v18"; then
+    echo -e "${GREEN}Node.js version 18 is installed.${NC}"
+else
+    echo -e "${RED}Node.js version 18 not installed.${NC}"
+    EXIT_CODE=1
+fi
+
+# Step 7a: Check Rust version
+if command_exists rustc && rustc --version | grep -q "1.80.1"; then
+    echo -e "${GREEN}Rust version 1.80.1 is installed.${NC}"
+else
+    echo -e "${RED}Rust version 1.80.1 not installed.${NC}"
+    EXIT_CODE=1
+fi
+
+# Step 7b: Check Rust nightly toolchain
+if rustup toolchain list | grep -q "nightly"; then
+    echo -e "${GREEN}Rust nightly toolchain is installed.${NC}"
+else
+    echo -e "${RED}Rust nightly toolchain is not installed. Install it using: rustup toolchain install nightly${NC}"
+    EXIT_CODE=1
+fi
+
+# Step 8: Check Go version
+go_version_needed=$(grep "^go " go.mod | awk '{print $2}')
+if command_exists go && go version | grep -q "$go_version_needed"; then
+    echo -e "${GREEN}Go version $go_version_needed is installed.${NC}"
+else
+    echo -e "${RED}Go version $go_version_needed not installed.${NC}"
+    EXIT_CODE=1
+fi
+
+# Step 9: Check Foundry installation
+if command_exists foundryup; then
+    echo -e "${GREEN}Foundry is installed.${NC}"
+else
+    echo -e "${RED}Foundry is not installed.${NC}"
+    EXIT_CODE=1
+fi
+
+echo -e "${BLUE}Verification complete.${NC}"
+
+if [ $EXIT_CODE != 0 ]; then
+    echo -e "${RED}One or more dependencies missing. $INSTALLATION_DOCS_URL${NC}"
+fi
+
+exit $EXIT_CODE
+
diff --git a/staker/stateless_block_validator.go b/staker/stateless_block_validator.go
index 9257c5582a..d9c9c5446b 100644
--- a/staker/stateless_block_validator.go
+++ b/staker/stateless_block_validator.go
@@ -511,12 +511,12 @@ func (v *StatelessBlockValidator) ValidateResult(
 	return true, &entry.End, nil
 }
 
-func (v *StatelessBlockValidator) ValidationInputsAt(ctx context.Context, pos arbutil.MessageIndex, target ethdb.WasmTarget) (server_api.InputJSON, error) {
+func (v *StatelessBlockValidator) ValidationInputsAt(ctx context.Context, pos arbutil.MessageIndex, targets ...ethdb.WasmTarget) (server_api.InputJSON, error) {
 	entry, err := v.CreateReadyValidationEntry(ctx, pos)
 	if err != nil {
 		return server_api.InputJSON{}, err
 	}
-	input, err := entry.ToInput([]ethdb.WasmTarget{target})
+	input, err := entry.ToInput(targets)
 	if err != nil {
 		return server_api.InputJSON{}, err
 	}
diff --git a/system_tests/common_test.go b/system_tests/common_test.go
index dbb2b86f13..027a41d875 100644
--- a/system_tests/common_test.go
+++ b/system_tests/common_test.go
@@ -9,6 +9,7 @@ import (
 	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
+	"flag"
 	"io"
 	"math/big"
 	"net"
@@ -1716,11 +1717,23 @@ func logParser[T any](t *testing.T, source string, name string) func(*types.Log)
 	}
 }
 
+var (
+	recordBlockInputsEnable                       = flag.Bool("recordBlockInputs.enable", true, "Whether to record block inputs as a json file")
+	recordBlockInputsWithSlug                     = flag.String("recordBlockInputs.WithSlug", "", "Slug directory for validationInputsWriter")
+	recordBlockInputsWithBaseDir                  = flag.String("recordBlockInputs.WithBaseDir", "", "Base directory for validationInputsWriter")
+	recordBlockInputsWithTimestampDirEnabled      = flag.Bool("recordBlockInputs.WithTimestampDirEnabled", true, "Whether to add timestamp directory while recording block inputs")
+	recordBlockInputsWithBlockIdInFileNameEnabled = flag.Bool("recordBlockInputs.WithBlockIdInFileNameEnabled", true, "Whether to record block inputs using test specific block_id")
+)
+
 // recordBlock writes a json file with all of the data needed to validate a block.
 //
 // This can be used as an input to the arbitrator prover to validate a block.
-func recordBlock(t *testing.T, block uint64, builder *NodeBuilder) {
+func recordBlock(t *testing.T, block uint64, builder *NodeBuilder, targets ...ethdb.WasmTarget) {
 	t.Helper()
+	flag.Parse()
+	if !*recordBlockInputsEnable {
+		return
+	}
 	ctx := builder.ctx
 	inboxPos := arbutil.MessageIndex(block)
 	for {
@@ -1733,9 +1746,20 @@ func recordBlock(t *testing.T, block uint64, builder *NodeBuilder) {
 			break
 		}
 	}
-	validationInputsWriter, err := inputs.NewWriter(inputs.WithSlug(t.Name()))
+	var options []inputs.WriterOption
+	options = append(options, inputs.WithTimestampDirEnabled(*recordBlockInputsWithTimestampDirEnabled))
+	options = append(options, inputs.WithBlockIdInFileNameEnabled(*recordBlockInputsWithBlockIdInFileNameEnabled))
+	if *recordBlockInputsWithBaseDir != "" {
+		options = append(options, inputs.WithBaseDir(*recordBlockInputsWithBaseDir))
+	}
+	if *recordBlockInputsWithSlug != "" {
+		options = append(options, inputs.WithSlug(*recordBlockInputsWithSlug))
+	} else {
+		options = append(options, inputs.WithSlug(t.Name()))
+	}
+	validationInputsWriter, err := inputs.NewWriter(options...)
 	Require(t, err)
-	inputJson, err := builder.L2.ConsensusNode.StatelessBlockValidator.ValidationInputsAt(ctx, inboxPos, rawdb.TargetWavm)
+	inputJson, err := builder.L2.ConsensusNode.StatelessBlockValidator.ValidationInputsAt(ctx, inboxPos, targets...)
 	if err != nil {
 		Fatal(t, "failed to get validation inputs", block, err)
 	}
diff --git a/system_tests/forwarder_test.go b/system_tests/forwarder_test.go
index 57381ca84e..6a1d1c68d8 100644
--- a/system_tests/forwarder_test.go
+++ b/system_tests/forwarder_test.go
@@ -170,7 +170,7 @@ func waitForSequencerLockout(ctx context.Context, node *arbnode.Node, duration t
 		case <-time.After(duration):
 			return fmt.Errorf("no sequencer was chosen")
 		default:
-			if c, err := node.SeqCoordinator.CurrentChosenSequencer(ctx); err == nil && c != "" {
+			if c, err := node.SeqCoordinator.RedisCoordinator().CurrentChosenSequencer(ctx); err == nil && c != "" {
 				return nil
 			}
 			time.Sleep(100 * time.Millisecond)
diff --git a/system_tests/program_test.go b/system_tests/program_test.go
index 4755096b26..4c896d1791 100644
--- a/system_tests/program_test.go
+++ b/system_tests/program_test.go
@@ -423,9 +423,9 @@ func storageTest(t *testing.T, jit bool) {
 
 	validateBlocks(t, 2, jit, builder)
 
-	// Captures a block_input_<id>.json file for the block that included the
-	// storage write transaction.
-	recordBlock(t, receipt.BlockNumber.Uint64(), builder)
+	// Captures a block_inputs json file for the block that included the
+	// storage write transaction. Include wasm targets necessary for arbitrator prover and jit binaries
+	recordBlock(t, receipt.BlockNumber.Uint64(), builder, rawdb.TargetWavm, rawdb.LocalTarget())
 }
 
 func TestProgramTransientStorage(t *testing.T) {
diff --git a/system_tests/seq_coordinator_test.go b/system_tests/seq_coordinator_test.go
index e9b2adabe8..e7d8bf6b39 100644
--- a/system_tests/seq_coordinator_test.go
+++ b/system_tests/seq_coordinator_test.go
@@ -373,3 +373,77 @@ func TestRedisSeqCoordinatorMessageSync(t *testing.T) {
 func TestRedisSeqCoordinatorWrongKeyMessageSync(t *testing.T) {
 	testCoordinatorMessageSync(t, false)
 }
+
+func TestRedisSwitchover(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	builder.nodeConfig.SeqCoordinator.Enable = true
+	builder.nodeConfig.SeqCoordinator.RedisUrl = redisutil.CreateTestRedis(ctx, t)
+	builder.nodeConfig.SeqCoordinator.NewRedisUrl = redisutil.CreateTestRedis(ctx, t)
+	builder.nodeConfig.BatchPoster.Enable = false
+
+	nodeNames := []string{"stdio://A", "stdio://B"}
+	initRedisForTest(t, ctx, builder.nodeConfig.SeqCoordinator.RedisUrl, nodeNames)
+	initRedisForTest(t, ctx, builder.nodeConfig.SeqCoordinator.NewRedisUrl, nodeNames)
+	builder.nodeConfig.SeqCoordinator.MyUrl = nodeNames[0]
+
+	cleanup := builder.Build(t)
+	defer cleanup()
+
+	redisClient, err := redisutil.RedisClientFromURL(builder.nodeConfig.SeqCoordinator.RedisUrl)
+	Require(t, err)
+
+	// wait for sequencerA to become master
+	for {
+		err := redisClient.Get(ctx, redisutil.CHOSENSEQ_KEY).Err()
+		if errors.Is(err, redis.Nil) {
+			time.Sleep(builder.nodeConfig.SeqCoordinator.UpdateInterval)
+			continue
+		}
+		Require(t, err)
+		break
+	}
+
+	builder.L2Info.GenerateAccount("User2")
+
+	nodeConfigDup := *builder.nodeConfig
+	builder.nodeConfig = &nodeConfigDup
+	builder.nodeConfig.Feed.Output = *newBroadcasterConfigTest()
+	builder.nodeConfig.SeqCoordinator.MyUrl = nodeNames[1]
+	testClientB, cleanupB := builder.Build2ndNode(t, &SecondNodeParams{nodeConfig: builder.nodeConfig})
+	defer cleanupB()
+
+	verifyTxIsProcessed(t, ctx, builder, testClientB, 1e12)
+
+	redisClient.Set(ctx, redisutil.CHOSENSEQ_KEY, redisutil.SWITCHED_REDIS, time.Duration(-1))
+
+	verifyTxIsProcessed(t, ctx, builder, testClientB, 1e12*2)
+
+	// Wait for all messages to be processed, before closing old redisClient
+	time.Sleep(1 * time.Second)
+	err = redisClient.Close()
+	Require(t, err)
+
+	verifyTxIsProcessed(t, ctx, builder, testClientB, 1e12*3)
+
+}
+
+func verifyTxIsProcessed(t *testing.T, ctx context.Context, builder *NodeBuilder, testClientB *TestClient, balance int64) {
+	tx := builder.L2Info.PrepareTx("Owner", "User2", builder.L2Info.TransferGas, big.NewInt(1e12), nil)
+
+	err := builder.L2.Client.SendTransaction(ctx, tx)
+	Require(t, err)
+
+	_, err = builder.L2.EnsureTxSucceeded(tx)
+	Require(t, err)
+
+	_, err = WaitForTx(ctx, testClientB.Client, tx.Hash(), time.Second*5)
+	Require(t, err)
+	l2balance, err := testClientB.Client.BalanceAt(ctx, builder.L2Info.GetAddress("User2"), nil)
+	Require(t, err)
+	if l2balance.Cmp(big.NewInt(balance)) != 0 {
+		t.Fatal("Unexpected balance:", l2balance)
+	}
+}
diff --git a/util/redisutil/redis_coordinator.go b/util/redisutil/redis_coordinator.go
index 62cf76c0bd..39db7c8645 100644
--- a/util/redisutil/redis_coordinator.go
+++ b/util/redisutil/redis_coordinator.go
@@ -21,6 +21,7 @@ const WANTS_LOCKOUT_KEY_PREFIX string = "coordinator.liveliness."      // Per se
 const MESSAGE_KEY_PREFIX string = "coordinator.msg."                   // Per Message. Only written by sequencer holding CHOSEN
 const SIGNATURE_KEY_PREFIX string = "coordinator.msg.sig."             // Per Message. Only written by sequencer holding CHOSEN
 const WANTS_LOCKOUT_VAL string = "OK"
+const SWITCHED_REDIS string = "SWITCHED_REDIS"
 const INVALID_VAL string = "INVALID"
 const INVALID_URL string = "<?INVALID-URL?>"
 
diff --git a/validator/inputs/writer.go b/validator/inputs/writer.go
index a45e584f52..1a476c52a3 100644
--- a/validator/inputs/writer.go
+++ b/validator/inputs/writer.go
@@ -17,20 +17,25 @@ import (
 //
 // The path can be nested under a slug directory so callers can provide a
 // recognizable name to differentiate various contexts in which the InputJSON
-// is being written. If the Writer is configured by calling SetSlug, then the
+// is being written. If the Writer is configured by calling WithSlug, then the
 // path will be like:
 //
 //	$HOME/.arbuitrum/validation-inputs/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
 //
+// The inclusion of BlockId in the file's name is on by default, however that can be disabled
+// by calling WithBlockIdInFileNameEnabled(false). In which case, the path will be like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<slug>/<YYYMMDD_HHMMSS>/block_inputs.json
+//
 // The inclusion of a timestamp directory is on by default to avoid conflicts which
 // would result in files being overwritten. However, the Writer can be configured
 // to not use a timestamp directory.  If the Writer is configured by calling
-// SetUseTimestampDir(false), then the path will be like:
+// WithTimestampDirEnabled(false), then the path will be like:
 //
 //	$HOME/.arbuitrum/validation-inputs/<slug>/block_inputs_<id>.json
 //
 // Finally, to give complete control to the clients, the base directory can be
-// set directly with SetBaseDir. In which case, the path will be like:
+// set directly with WithBaseDir. In which case, the path will be like:
 //
 //	<baseDir>/block_inputs_<id>.json
 //	  or
@@ -38,10 +43,11 @@ import (
 //	  or
 //	<baseDir>/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
 type Writer struct {
-	clock           Clock
-	baseDir         string
-	slug            string
-	useTimestampDir bool
+	clock                Clock
+	baseDir              string
+	slug                 string
+	useTimestampDir      bool
+	useBlockIdInFileName bool
 }
 
 // WriterOption is a function that configures a Writer.
@@ -66,10 +72,11 @@ func NewWriter(options ...WriterOption) (*Writer, error) {
 	}
 	baseDir := filepath.Join(homeDir, ".arbitrum", "validation-inputs")
 	w := &Writer{
-		clock:           realClock{},
-		baseDir:         baseDir,
-		slug:            "",
-		useTimestampDir: true,
+		clock:                realClock{},
+		baseDir:              baseDir,
+		slug:                 "",
+		useTimestampDir:      true,
+		useBlockIdInFileName: true,
 	}
 	for _, o := range options {
 		o(w)
@@ -114,6 +121,13 @@ func WithTimestampDirEnabled(useTimestampDir bool) WriterOption {
 	}
 }
 
+// WithBlockIdInFileNameEnabled controls the inclusion of Block Id in the input json file's name
+func WithBlockIdInFileNameEnabled(useBlockIdInFileName bool) WriterOption {
+	return func(w *Writer) {
+		w.useBlockIdInFileName = useBlockIdInFileName
+	}
+}
+
 // Write writes the given InputJSON to a file in JSON format.
 func (w *Writer) Write(json *server_api.InputJSON) error {
 	dir := w.baseDir
@@ -132,9 +146,11 @@ func (w *Writer) Write(json *server_api.InputJSON) error {
 	if err != nil {
 		return err
 	}
-	if err = os.WriteFile(
-		filepath.Join(dir, fmt.Sprintf("block_inputs_%d.json", json.Id)),
-		contents, 0600); err != nil {
+	fileName := "block_inputs.json"
+	if w.useBlockIdInFileName {
+		fileName = fmt.Sprintf("block_inputs_%d.json", json.Id)
+	}
+	if err = os.WriteFile(filepath.Join(dir, fileName), contents, 0600); err != nil {
 		return err
 	}
 	return nil