diff --git a/.github/workflows/arbitrator-ci.yml b/.github/workflows/arbitrator-ci.yml
index dd58a30571..0355ebb722 100644
--- a/.github/workflows/arbitrator-ci.yml
+++ b/.github/workflows/arbitrator-ci.yml
@@ -66,20 +66,29 @@ jobs:
           cache: 'yarn'
           cache-dependency-path: '**/yarn.lock'
 
-      - name: Install rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: 'stable'
-          components: 'llvm-tools-preview, rustfmt, clippy'
-
       - name: Install rust nightly
         uses: dtolnay/rust-toolchain@nightly
         id: install-rust-nightly
         with:
-          toolchain: 'nightly-2024-08-06'
+          toolchain: 'nightly-2024-10-06'
           targets: 'wasm32-wasi, wasm32-unknown-unknown'
           components: 'rust-src, rustfmt, clippy'
 
+      - name: Install rust stable
+        id: install-rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: '1.80.1'
+          targets: 'wasm32-wasi, wasm32-unknown-unknown'
+          components: 'llvm-tools-preview, rustfmt, clippy'
+
+      - name: Install rust stable
+        id: install-rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: '1.80.1'
+          components: 'llvm-tools-preview, rustfmt, clippy'
+
       - name: Set STYLUS_NIGHTLY_VER environment variable
         run: echo "STYLUS_NIGHTLY_VER=+$(rustup toolchain list | grep '^nightly' | head -n1 | cut -d' ' -f1)" >> "$GITHUB_ENV"
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1eda1d9b7e..b4ce5bf27f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,8 +55,9 @@ jobs:
 
       - name: Install rust stable
         uses: dtolnay/rust-toolchain@stable
+        id: install-rust
         with:
-          toolchain: 'stable'
+          toolchain: '1.80.1'
           targets: 'wasm32-wasi, wasm32-unknown-unknown'
           components: 'llvm-tools-preview, rustfmt, clippy'
 
@@ -64,7 +65,7 @@ jobs:
         uses: dtolnay/rust-toolchain@nightly
         id: install-rust-nightly
         with:
-          toolchain: 'nightly-2024-08-06'
+          toolchain: 'nightly-2024-10-06'
           targets: 'wasm32-wasi, wasm32-unknown-unknown'
           components: 'rust-src, rustfmt, clippy'
 
diff --git a/.github/workflows/submodule-pin-check.yml b/.github/workflows/submodule-pin-check.yml
index 94fa705655..a6a7d9b66c 100644
--- a/.github/workflows/submodule-pin-check.yml
+++ b/.github/workflows/submodule-pin-check.yml
@@ -30,7 +30,7 @@ jobs:
 
             #TODO Rachel to check these are the intended branches.
             [arbitrator/langs/c]=origin/vm-storage-cache
-            [arbitrator/tools/wasmer]=origin/adopt-v4.2.8
+            [arbitrator/tools/wasmer]=origin/stylus
           )
           divergent=0
           for mod in `git submodule --quiet foreach 'echo $name'`; do
diff --git a/Makefile b/Makefile
index 12dfb07cf8..39b221dcee 100644
--- a/Makefile
+++ b/Makefile
@@ -440,54 +440,80 @@ $(stylus_test_dir)/%.wasm: $(stylus_test_dir)/%.b $(stylus_lang_bf)
 
 $(stylus_test_keccak_wasm): $(stylus_test_keccak_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_keccak-100_wasm): $(stylus_test_keccak-100_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_fallible_wasm): $(stylus_test_fallible_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_storage_wasm): $(stylus_test_storage_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_multicall_wasm): $(stylus_test_multicall_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_log_wasm): $(stylus_test_log_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_create_wasm): $(stylus_test_create_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_math_wasm): $(stylus_test_math_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_evm-data_wasm): $(stylus_test_evm-data_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_read-return-data_wasm): $(stylus_test_read-return-data_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_sdk-storage_wasm): $(stylus_test_sdk-storage_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_erc20_wasm): $(stylus_test_erc20_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 $(stylus_test_hostio-test_wasm): $(stylus_test_hostio-test_src)
 	$(cargo_nightly) --manifest-path $< --release --config $(stylus_cargo)
+	wasm2wat $@ > $@.wat #removing reference types
+	wat2wasm $@.wat -o $@
 	@touch -c $@ # cargo might decide to not rebuild the binary
 
 contracts/test/prover/proofs/float%.json: $(arbitrator_cases)/float%.wasm $(prover_bin) $(output_latest)/soft-float.wasm
diff --git a/arbitrator/arbutil/src/operator.rs b/arbitrator/arbutil/src/operator.rs
index cc1f684366..9abf237a66 100644
--- a/arbitrator/arbutil/src/operator.rs
+++ b/arbitrator/arbutil/src/operator.rs
@@ -595,13 +595,13 @@ impl Display for OperatorCode {
     }
 }
 
-impl<'a> From<Operator<'a>> for OperatorCode {
+impl From<Operator<'_>> for OperatorCode {
     fn from(op: Operator) -> Self {
         OperatorCode::from(&op)
     }
 }
 
-impl<'a> From<&Operator<'a>> for OperatorCode {
+impl From<&Operator<'_>> for OperatorCode {
     fn from(op: &Operator) -> Self {
         use Operator as O;
 
diff --git a/arbitrator/jit/src/caller_env.rs b/arbitrator/jit/src/caller_env.rs
index 41240d3d98..9fe4288d21 100644
--- a/arbitrator/jit/src/caller_env.rs
+++ b/arbitrator/jit/src/caller_env.rs
@@ -34,7 +34,7 @@ impl<'a> JitEnv<'a> for WasmEnvMut<'a> {
     }
 }
 
-impl<'s> JitMemAccess<'s> {
+impl JitMemAccess<'_> {
     fn view(&self) -> MemoryView {
         self.memory.view(&self.store)
     }
diff --git a/arbitrator/prover/src/binary.rs b/arbitrator/prover/src/binary.rs
index 2260f6bf48..77bc44ec4c 100644
--- a/arbitrator/prover/src/binary.rs
+++ b/arbitrator/prover/src/binary.rs
@@ -499,7 +499,7 @@ pub fn parse<'a>(input: &'a [u8], path: &'_ Path) -> Result<WasmBinary<'a>> {
     Ok(binary)
 }
 
-impl<'a> Debug for WasmBinary<'a> {
+impl Debug for WasmBinary<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("WasmBinary")
             .field("types", &self.types)
diff --git a/arbitrator/prover/src/programs/counter.rs b/arbitrator/prover/src/programs/counter.rs
index cd54178cf8..4006e70ee6 100644
--- a/arbitrator/prover/src/programs/counter.rs
+++ b/arbitrator/prover/src/programs/counter.rs
@@ -75,7 +75,7 @@ pub struct FuncCounter<'a> {
     block: Vec<Operator<'a>>,
 }
 
-impl<'a> FuncCounter<'a> {
+impl FuncCounter<'_> {
     fn new(counters: Arc<Mutex<Vec<GlobalIndex>>>) -> Self {
         let block = vec![];
         Self { counters, block }
diff --git a/arbitrator/prover/src/programs/depth.rs b/arbitrator/prover/src/programs/depth.rs
index 2000190917..fb0e0cb6d2 100644
--- a/arbitrator/prover/src/programs/depth.rs
+++ b/arbitrator/prover/src/programs/depth.rs
@@ -107,7 +107,7 @@ pub struct FuncDepthChecker<'a> {
     done: bool,
 }
 
-impl<'a> FuncDepthChecker<'a> {
+impl FuncDepthChecker<'_> {
     fn new(
         global: GlobalIndex,
         funcs: Arc<HashMap<FunctionIndex, FunctionType>>,
@@ -227,7 +227,7 @@ impl<'a> FuncMiddleware<'a> for FuncDepthChecker<'a> {
     }
 }
 
-impl<'a> FuncDepthChecker<'a> {
+impl FuncDepthChecker<'_> {
     fn worst_case_depth(&self) -> Result<u32> {
         use Operator::*;
 
diff --git a/arbitrator/prover/src/programs/meter.rs b/arbitrator/prover/src/programs/meter.rs
index 0d7b3151d7..cfb91e647d 100644
--- a/arbitrator/prover/src/programs/meter.rs
+++ b/arbitrator/prover/src/programs/meter.rs
@@ -1,5 +1,6 @@
 // Copyright 2022-2023, Offchain Labs, Inc.
 // For license information, see https://github.com/nitro/blob/master/LICENSE
+#![allow(clippy::needless_lifetimes)]
 
 use crate::{
     programs::{
@@ -122,7 +123,7 @@ pub struct FuncMeter<'a, F: OpcodePricer> {
     sigs: Arc<SigMap>,
 }
 
-impl<'a, F: OpcodePricer> FuncMeter<'a, F> {
+impl<F: OpcodePricer> FuncMeter<'_, F> {
     fn new(
         ink_global: GlobalIndex,
         status_global: GlobalIndex,
diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs
index a35308e7ff..517ccc1971 100644
--- a/arbitrator/prover/src/programs/mod.rs
+++ b/arbitrator/prover/src/programs/mod.rs
@@ -244,7 +244,7 @@ impl ModuleMod for ModuleInfo {
     fn drop_exports_and_names(&mut self, keep: &HashMap<&str, ExportKind>) {
         self.exports.retain(|name, export| {
             keep.get(name.as_str())
-                .map_or(false, |x| *x == (*export).into())
+                .is_some_and(|x| *x == (*export).into())
         });
         self.function_names.clear();
     }
@@ -263,7 +263,7 @@ impl ModuleMod for ModuleInfo {
     }
 }
 
-impl<'a> ModuleMod for WasmBinary<'a> {
+impl ModuleMod for WasmBinary<'_> {
     fn add_global(&mut self, name: &str, _ty: Type, init: GlobalInit) -> Result<GlobalIndex> {
         let global = match init {
             GlobalInit::I32Const(x) => Value::I32(x as u32),
@@ -364,7 +364,7 @@ impl<'a> ModuleMod for WasmBinary<'a> {
 
     fn drop_exports_and_names(&mut self, keep: &HashMap<&str, ExportKind>) {
         self.exports
-            .retain(|name, ty| keep.get(name.as_str()).map_or(false, |x| *x == ty.1));
+            .retain(|name, ty| keep.get(name.as_str()).is_some_and(|x| *x == ty.1));
         self.names.functions.clear();
     }
 
diff --git a/arbitrator/stylus/src/env.rs b/arbitrator/stylus/src/env.rs
index a2c8189029..ef12d2480a 100644
--- a/arbitrator/stylus/src/env.rs
+++ b/arbitrator/stylus/src/env.rs
@@ -147,7 +147,7 @@ pub struct HostioInfo<'a, D: DataReader, E: EvmApi<D>> {
     pub start_ink: Ink,
 }
 
-impl<'a, D: DataReader, E: EvmApi<D>> HostioInfo<'a, D, E> {
+impl<D: DataReader, E: EvmApi<D>> HostioInfo<'_, D, E> {
     pub fn config(&self) -> StylusConfig {
         self.config.expect("no config")
     }
@@ -172,7 +172,7 @@ impl<'a, D: DataReader, E: EvmApi<D>> HostioInfo<'a, D, E> {
     }
 }
 
-impl<'a, D: DataReader, E: EvmApi<D>> MeteredMachine for HostioInfo<'a, D, E> {
+impl<D: DataReader, E: EvmApi<D>> MeteredMachine for HostioInfo<'_, D, E> {
     fn ink_left(&self) -> MachineMeter {
         let vm = self.env.meter();
         match vm.status() {
@@ -188,13 +188,13 @@ impl<'a, D: DataReader, E: EvmApi<D>> MeteredMachine for HostioInfo<'a, D, E> {
     }
 }
 
-impl<'a, D: DataReader, E: EvmApi<D>> GasMeteredMachine for HostioInfo<'a, D, E> {
+impl<D: DataReader, E: EvmApi<D>> GasMeteredMachine for HostioInfo<'_, D, E> {
     fn pricing(&self) -> PricingParams {
         self.config().pricing
     }
 }
 
-impl<'a, D: DataReader, E: EvmApi<D>> Deref for HostioInfo<'a, D, E> {
+impl<D: DataReader, E: EvmApi<D>> Deref for HostioInfo<'_, D, E> {
     type Target = WasmEnv<D, E>;
 
     fn deref(&self) -> &Self::Target {
@@ -202,7 +202,7 @@ impl<'a, D: DataReader, E: EvmApi<D>> Deref for HostioInfo<'a, D, E> {
     }
 }
 
-impl<'a, D: DataReader, E: EvmApi<D>> DerefMut for HostioInfo<'a, D, E> {
+impl<D: DataReader, E: EvmApi<D>> DerefMut for HostioInfo<'_, D, E> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.env
     }
diff --git a/arbitrator/stylus/src/host.rs b/arbitrator/stylus/src/host.rs
index 67497302a1..c4fc7cea1e 100644
--- a/arbitrator/stylus/src/host.rs
+++ b/arbitrator/stylus/src/host.rs
@@ -22,7 +22,7 @@ use std::{
 use user_host_trait::UserHost;
 use wasmer::{MemoryAccessError, WasmPtr};
 
-impl<'a, DR, A> UserHost<DR> for HostioInfo<'a, DR, A>
+impl<DR, A> UserHost<DR> for HostioInfo<'_, DR, A>
 where
     DR: DataReader,
     A: EvmApi<DR>,
diff --git a/arbitrator/stylus/tests/.cargo/config.toml b/arbitrator/stylus/tests/.cargo/config.toml
index 702a5c04b3..6ca5e18651 100644
--- a/arbitrator/stylus/tests/.cargo/config.toml
+++ b/arbitrator/stylus/tests/.cargo/config.toml
@@ -5,6 +5,7 @@ target = "wasm32-unknown-unknown"
 rustflags = [
   "-C", "target-cpu=mvp",
   "-C", "link-arg=-zstack-size=8192",
+  "-C", "target-feature=-reference-types",
 #  "-C", "link-arg=--export=__heap_base",
 #  "-C", "link-arg=--export=__data_end",
 ]
diff --git a/arbnode/message_pruner.go b/arbnode/message_pruner.go
index 08f568796d..dedc579a01 100644
--- a/arbnode/message_pruner.go
+++ b/arbnode/message_pruner.go
@@ -15,6 +15,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rlp"
 
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/util/stopwaiter"
@@ -23,15 +24,13 @@ import (
 
 type MessagePruner struct {
 	stopwaiter.StopWaiter
-	transactionStreamer              *TransactionStreamer
-	inboxTracker                     *InboxTracker
-	config                           MessagePrunerConfigFetcher
-	pruningLock                      sync.Mutex
-	lastPruneDone                    time.Time
-	cachedPrunedMessages             uint64
-	cachedPrunedBlockHashesInputFeed uint64
-	cachedPrunedMessageResult        uint64
-	cachedPrunedDelayedMessages      uint64
+	transactionStreamer         *TransactionStreamer
+	inboxTracker                *InboxTracker
+	config                      MessagePrunerConfigFetcher
+	pruningLock                 sync.Mutex
+	lastPruneDone               time.Time
+	cachedPrunedMessages        uint64
+	cachedPrunedDelayedMessages uint64
 }
 
 type MessagePrunerConfig struct {
@@ -121,7 +120,13 @@ func (m *MessagePruner) prune(ctx context.Context, count arbutil.MessageIndex, g
 }
 
 func (m *MessagePruner) deleteOldMessagesFromDB(ctx context.Context, messageCount arbutil.MessageIndex, delayedMessageCount uint64) error {
-	prunedKeysRange, err := deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, messageResultPrefix, &m.cachedPrunedMessageResult, uint64(messageCount))
+	if m.cachedPrunedMessages == 0 {
+		m.cachedPrunedMessages = fetchLastPrunedKey(m.transactionStreamer.db, lastPrunedMessageKey)
+	}
+	if m.cachedPrunedDelayedMessages == 0 {
+		m.cachedPrunedDelayedMessages = fetchLastPrunedKey(m.inboxTracker.db, lastPrunedDelayedMessageKey)
+	}
+	prunedKeysRange, _, err := deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, messageResultPrefix, m.cachedPrunedMessages, uint64(messageCount))
 	if err != nil {
 		return fmt.Errorf("error deleting message results: %w", err)
 	}
@@ -129,7 +134,7 @@ func (m *MessagePruner) deleteOldMessagesFromDB(ctx context.Context, messageCoun
 		log.Info("Pruned message results:", "first pruned key", prunedKeysRange[0], "last pruned key", prunedKeysRange[len(prunedKeysRange)-1])
 	}
 
-	prunedKeysRange, err = deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, blockHashInputFeedPrefix, &m.cachedPrunedBlockHashesInputFeed, uint64(messageCount))
+	prunedKeysRange, _, err = deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, blockHashInputFeedPrefix, m.cachedPrunedMessages, uint64(messageCount))
 	if err != nil {
 		return fmt.Errorf("error deleting expected block hashes: %w", err)
 	}
@@ -137,43 +142,77 @@ func (m *MessagePruner) deleteOldMessagesFromDB(ctx context.Context, messageCoun
 		log.Info("Pruned expected block hashes:", "first pruned key", prunedKeysRange[0], "last pruned key", prunedKeysRange[len(prunedKeysRange)-1])
 	}
 
-	prunedKeysRange, err = deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, messagePrefix, &m.cachedPrunedMessages, uint64(messageCount))
+	prunedKeysRange, lastPrunedMessage, err := deleteFromLastPrunedUptoEndKey(ctx, m.transactionStreamer.db, messagePrefix, m.cachedPrunedMessages, uint64(messageCount))
 	if err != nil {
 		return fmt.Errorf("error deleting last batch messages: %w", err)
 	}
 	if len(prunedKeysRange) > 0 {
 		log.Info("Pruned last batch messages:", "first pruned key", prunedKeysRange[0], "last pruned key", prunedKeysRange[len(prunedKeysRange)-1])
 	}
+	insertLastPrunedKey(m.transactionStreamer.db, lastPrunedMessageKey, lastPrunedMessage)
+	m.cachedPrunedMessages = lastPrunedMessage
 
-	prunedKeysRange, err = deleteFromLastPrunedUptoEndKey(ctx, m.inboxTracker.db, rlpDelayedMessagePrefix, &m.cachedPrunedDelayedMessages, delayedMessageCount)
+	prunedKeysRange, lastPrunedDelayedMessage, err := deleteFromLastPrunedUptoEndKey(ctx, m.inboxTracker.db, rlpDelayedMessagePrefix, m.cachedPrunedDelayedMessages, delayedMessageCount)
 	if err != nil {
 		return fmt.Errorf("error deleting last batch delayed messages: %w", err)
 	}
 	if len(prunedKeysRange) > 0 {
 		log.Info("Pruned last batch delayed messages:", "first pruned key", prunedKeysRange[0], "last pruned key", prunedKeysRange[len(prunedKeysRange)-1])
 	}
+	insertLastPrunedKey(m.inboxTracker.db, lastPrunedDelayedMessageKey, lastPrunedDelayedMessage)
+	m.cachedPrunedDelayedMessages = lastPrunedDelayedMessage
 	return nil
 }
 
-// deleteFromLastPrunedUptoEndKey is similar to deleteFromRange but automatically populates the start key
-// cachedStartMinKey must not be nil. It's set to the new start key at the end of this function if successful.
-func deleteFromLastPrunedUptoEndKey(ctx context.Context, db ethdb.Database, prefix []byte, cachedStartMinKey *uint64, endMinKey uint64) ([]uint64, error) {
-	startMinKey := *cachedStartMinKey
+// deleteFromLastPrunedUptoEndKey is similar to deleteFromRange but automatically populates the start key if it's not set.
+// It's returns the new start key (i.e. last pruned key) at the end of this function if successful.
+func deleteFromLastPrunedUptoEndKey(ctx context.Context, db ethdb.Database, prefix []byte, startMinKey uint64, endMinKey uint64) ([]uint64, uint64, error) {
 	if startMinKey == 0 {
 		startIter := db.NewIterator(prefix, uint64ToKey(1))
 		if !startIter.Next() {
-			return nil, nil
+			return nil, 0, nil
 		}
 		startMinKey = binary.BigEndian.Uint64(bytes.TrimPrefix(startIter.Key(), prefix))
 		startIter.Release()
 	}
 	if endMinKey <= startMinKey {
-		*cachedStartMinKey = startMinKey
-		return nil, nil
+		return nil, startMinKey, nil
 	}
 	keys, err := deleteFromRange(ctx, db, prefix, startMinKey, endMinKey-1)
-	if err == nil {
-		*cachedStartMinKey = endMinKey - 1
+	return keys, endMinKey - 1, err
+}
+
+func insertLastPrunedKey(db ethdb.Database, lastPrunedKey []byte, lastPrunedValue uint64) {
+	lastPrunedValueByte, err := rlp.EncodeToBytes(lastPrunedValue)
+	if err != nil {
+		log.Error("error encoding last pruned value: %w", err)
+	} else {
+		err = db.Put(lastPrunedKey, lastPrunedValueByte)
+		if err != nil {
+			log.Error("error saving last pruned value: %w", err)
+		}
+	}
+}
+
+func fetchLastPrunedKey(db ethdb.Database, lastPrunedKey []byte) uint64 {
+	hasKey, err := db.Has(lastPrunedKey)
+	if err != nil {
+		log.Warn("error checking for last pruned key: %w", err)
+		return 0
+	}
+	if !hasKey {
+		return 0
+	}
+	lastPrunedValueByte, err := db.Get(lastPrunedKey)
+	if err != nil {
+		log.Warn("error fetching last pruned key: %w", err)
+		return 0
+	}
+	var lastPrunedValue uint64
+	err = rlp.DecodeBytes(lastPrunedValueByte, &lastPrunedValue)
+	if err != nil {
+		log.Warn("error decoding last pruned value: %w", err)
+		return 0
 	}
-	return keys, err
+	return lastPrunedValue
 }
diff --git a/arbnode/node.go b/arbnode/node.go
index f2e3433ecd..b9ac975176 100644
--- a/arbnode/node.go
+++ b/arbnode/node.go
@@ -212,6 +212,7 @@ func ConfigDefaultL1NonSequencerTest() *Config {
 	config.Staker = legacystaker.TestL1ValidatorConfig
 	config.Staker.Enable = false
 	config.BlockValidator.ValidationServerConfigs = []rpcclient.ClientConfig{{URL: ""}}
+	config.Bold.MinimumGapToParentAssertion = 0
 
 	return &config
 }
@@ -230,6 +231,7 @@ func ConfigDefaultL2Test() *Config {
 	config.Staker.Enable = false
 	config.BlockValidator.ValidationServerConfigs = []rpcclient.ClientConfig{{URL: ""}}
 	config.TransactionStreamer = DefaultTransactionStreamerConfig
+	config.Bold.MinimumGapToParentAssertion = 0
 
 	return &config
 }
@@ -285,19 +287,21 @@ type Node struct {
 }
 
 type SnapSyncConfig struct {
-	Enabled               bool
-	PrevBatchMessageCount uint64
-	PrevDelayedRead       uint64
-	BatchCount            uint64
-	DelayedCount          uint64
+	Enabled                   bool
+	PrevBatchMessageCount     uint64
+	PrevDelayedRead           uint64
+	BatchCount                uint64
+	DelayedCount              uint64
+	ParentChainAssertionBlock uint64
 }
 
 var DefaultSnapSyncConfig = SnapSyncConfig{
-	Enabled:               false,
-	PrevBatchMessageCount: 0,
-	BatchCount:            0,
-	DelayedCount:          0,
-	PrevDelayedRead:       0,
+	Enabled:                   false,
+	PrevBatchMessageCount:     0,
+	PrevDelayedRead:           0,
+	BatchCount:                0,
+	DelayedCount:              0,
+	ParentChainAssertionBlock: 0,
 }
 
 type ConfigFetcher interface {
@@ -596,7 +600,29 @@ func createNodeImpl(
 	if err != nil {
 		return nil, err
 	}
-	inboxReader, err := NewInboxReader(inboxTracker, l1client, l1Reader, new(big.Int).SetUint64(deployInfo.DeployedAt), delayedBridge, sequencerInbox, func() *InboxReaderConfig { return &configFetcher.Get().InboxReader })
+	firstMessageBlock := new(big.Int).SetUint64(deployInfo.DeployedAt)
+	if config.SnapSyncTest.Enabled {
+		batchCount := config.SnapSyncTest.BatchCount
+		delayedMessageNumber, err := exec.NextDelayedMessageNumber()
+		if err != nil {
+			return nil, err
+		}
+		if batchCount > delayedMessageNumber {
+			batchCount = delayedMessageNumber
+		}
+		// Find the first block containing the batch count.
+		// Subtract 1 to get the block before the needed batch count,
+		// this is done to fetch previous batch metadata needed for snap sync.
+		if batchCount > 0 {
+			batchCount--
+		}
+		block, err := FindBlockContainingBatchCount(ctx, deployInfo.Bridge, l1client, config.SnapSyncTest.ParentChainAssertionBlock, batchCount)
+		if err != nil {
+			return nil, err
+		}
+		firstMessageBlock.SetUint64(block)
+	}
+	inboxReader, err := NewInboxReader(inboxTracker, l1client, l1Reader, firstMessageBlock, delayedBridge, sequencerInbox, func() *InboxReaderConfig { return &configFetcher.Get().InboxReader })
 	if err != nil {
 		return nil, err
 	}
@@ -772,6 +798,53 @@ func createNodeImpl(
 	}, nil
 }
 
+func FindBlockContainingBatchCount(ctx context.Context, bridgeAddress common.Address, l1Client *ethclient.Client, parentChainAssertionBlock uint64, batchCount uint64) (uint64, error) {
+	bridge, err := bridgegen.NewIBridge(bridgeAddress, l1Client)
+	if err != nil {
+		return 0, err
+	}
+	high := parentChainAssertionBlock
+	low := uint64(0)
+	reduceBy := uint64(100)
+	if high > reduceBy {
+		low = high - reduceBy
+	}
+	// Reduce high and low by 100 until lowNode.InboxMaxCount < batchCount
+	// This will give us a range (low to high) of blocks that contain the batch count.
+	for low > 0 {
+		lowCount, err := bridge.SequencerMessageCount(&bind.CallOpts{Context: ctx, BlockNumber: new(big.Int).SetUint64(low)})
+		if err != nil {
+			return 0, err
+		}
+		if lowCount.Uint64() > batchCount {
+			high = low
+			reduceBy = reduceBy * 2
+			if low > reduceBy {
+				low = low - reduceBy
+			} else {
+				low = 0
+			}
+		} else {
+			break
+		}
+	}
+	// Then binary search between low and high to find the block containing the batch count.
+	for low < high {
+		mid := low + (high-low)/2
+
+		midCount, err := bridge.SequencerMessageCount(&bind.CallOpts{Context: ctx, BlockNumber: new(big.Int).SetUint64(mid)})
+		if err != nil {
+			return 0, err
+		}
+		if midCount.Uint64() < batchCount {
+			low = mid + 1
+		} else {
+			high = mid
+		}
+	}
+	return low, nil
+}
+
 func (n *Node) OnConfigReload(_ *Config, _ *Config) error {
 	// TODO
 	return nil
diff --git a/arbnode/schema.go b/arbnode/schema.go
index 1aaded2b95..88a31ce90a 100644
--- a/arbnode/schema.go
+++ b/arbnode/schema.go
@@ -13,10 +13,12 @@ var (
 	sequencerBatchMetaPrefix     []byte = []byte("s") // maps a batch sequence number to BatchMetadata
 	delayedSequencedPrefix       []byte = []byte("a") // maps a delayed message count to the first sequencer batch sequence number with this delayed count
 
-	messageCountKey        []byte = []byte("_messageCount")        // contains the current message count
-	delayedMessageCountKey []byte = []byte("_delayedMessageCount") // contains the current delayed message count
-	sequencerBatchCountKey []byte = []byte("_sequencerBatchCount") // contains the current sequencer message count
-	dbSchemaVersion        []byte = []byte("_schemaVersion")       // contains a uint64 representing the database schema version
+	messageCountKey             []byte = []byte("_messageCount")                // contains the current message count
+	lastPrunedMessageKey        []byte = []byte("_lastPrunedMessageKey")        // contains the last pruned message key
+	lastPrunedDelayedMessageKey []byte = []byte("_lastPrunedDelayedMessageKey") // contains the last pruned RLP delayed message key
+	delayedMessageCountKey      []byte = []byte("_delayedMessageCount")         // contains the current delayed message count
+	sequencerBatchCountKey      []byte = []byte("_sequencerBatchCount")         // contains the current sequencer message count
+	dbSchemaVersion             []byte = []byte("_schemaVersion")               // contains a uint64 representing the database schema version
 )
 
 const currentDbSchemaVersion uint64 = 1
diff --git a/arbos/arbosState/arbosstate.go b/arbos/arbosState/arbosstate.go
index 5ee070f942..de1a970b87 100644
--- a/arbos/arbosState/arbosstate.go
+++ b/arbos/arbosState/arbosstate.go
@@ -13,7 +13,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/triedb"
 	"github.com/ethereum/go-ethereum/triedb/hashdb"
@@ -123,13 +122,13 @@ func NewArbosMemoryBackedArbOSState() (*ArbosState, *state.StateDB) {
 	db := state.NewDatabaseWithConfig(raw, trieConfig)
 	statedb, err := state.New(common.Hash{}, db, nil)
 	if err != nil {
-		log.Crit("failed to init empty statedb", "error", err)
+		panic("failed to init empty statedb: " + err.Error())
 	}
 	burner := burn.NewSystemBurner(nil, false)
 	chainConfig := chaininfo.ArbitrumDevTestChainConfig()
 	newState, err := InitializeArbosState(statedb, burner, chainConfig, arbostypes.TestInitMessage)
 	if err != nil {
-		log.Crit("failed to open the ArbOS state", "error", err)
+		panic("failed to open the ArbOS state: " + err.Error())
 	}
 	return newState, statedb
 }
@@ -139,7 +138,7 @@ func ArbOSVersion(stateDB vm.StateDB) uint64 {
 	backingStorage := storage.NewGeth(stateDB, burn.NewSystemBurner(nil, false))
 	arbosVersion, err := backingStorage.GetUint64ByUint64(uint64(versionOffset))
 	if err != nil {
-		log.Crit("failed to get the ArbOS version", "error", err)
+		panic("failed to get the ArbOS version: " + err.Error())
 	}
 	return arbosVersion
 }
diff --git a/arbos/arbosState/initialize.go b/arbos/arbosState/initialize.go
index 8fd417c2b2..840204382c 100644
--- a/arbos/arbosState/initialize.go
+++ b/arbos/arbosState/initialize.go
@@ -66,7 +66,7 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 	}()
 	statedb, err := state.New(common.Hash{}, stateDatabase, nil)
 	if err != nil {
-		log.Crit("failed to init empty statedb", "error", err)
+		panic("failed to init empty statedb :" + err.Error())
 	}
 
 	noStateTrieChangesToCommitError := regexp.MustCompile("^triedb layer .+ is disk layer$")
@@ -96,7 +96,7 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 	burner := burn.NewSystemBurner(nil, false)
 	arbosState, err := InitializeArbosState(statedb, burner, chainConfig, initMessage)
 	if err != nil {
-		log.Crit("failed to open the ArbOS state", "error", err)
+		panic("failed to open the ArbOS state :" + err.Error())
 	}
 
 	chainOwner, err := initData.GetChainOwner()
diff --git a/arbos/programs/api.go b/arbos/programs/api.go
index d8f12ffbd3..a622f55397 100644
--- a/arbos/programs/api.go
+++ b/arbos/programs/api.go
@@ -4,12 +4,13 @@
 package programs
 
 import (
+	"strconv"
+
 	"github.com/holiman/uint256"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos/util"
@@ -151,7 +152,7 @@ func newApiClosures(
 		case vm.STATICCALL:
 			ret, returnGas, err = evm.StaticCall(scope.Contract, contract, input, gas)
 		default:
-			log.Crit("unsupported call type", "opcode", opcode)
+			panic("unsupported call type: " + opcode.String())
 		}
 
 		interpreter.SetReturnData(ret)
@@ -266,7 +267,7 @@ func newApiClosures(
 		original := input
 
 		crash := func(reason string) {
-			log.Crit("bad API call", "reason", reason, "request", req, "len", len(original), "remaining", len(input))
+			panic("bad API call reason: " + reason + " request: " + strconv.Itoa(int(req)) + " len: " + strconv.Itoa(len(original)) + " remaining: " + strconv.Itoa(len(input)))
 		}
 		takeInput := func(needed int, reason string) []byte {
 			if len(input) < needed {
@@ -338,7 +339,7 @@ func newApiClosures(
 			case StaticCall:
 				opcode = vm.STATICCALL
 			default:
-				log.Crit("unsupported call type", "opcode", opcode)
+				panic("unsupported call type opcode: " + opcode.String())
 			}
 			contract := takeAddress()
 			value := takeU256()
@@ -414,8 +415,7 @@ func newApiClosures(
 			captureHostio(name, args, outs, startInk, endInk)
 			return []byte{}, nil, 0
 		default:
-			log.Crit("unsupported call type", "req", req)
-			return []byte{}, nil, 0
+			panic("unsupported call type: " + strconv.Itoa(int(req)))
 		}
 	}
 }
diff --git a/arbos/programs/native.go b/arbos/programs/native.go
index a996d50d8a..5995d9dafe 100644
--- a/arbos/programs/native.go
+++ b/arbos/programs/native.go
@@ -72,7 +72,9 @@ func activateProgram(
 	debug bool,
 	burner burn.Burner,
 ) (*activationInfo, error) {
-	info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft())
+	targets := db.Database().WasmTargets()
+	moduleActivationMandatory := true
+	info, asmMap, err := activateProgramInternal(program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft(), targets, moduleActivationMandatory)
 	if err != nil {
 		return nil, err
 	}
@@ -80,8 +82,7 @@ func activateProgram(
 	return info, nil
 }
 
-func activateProgramInternal(
-	db vm.StateDB,
+func activateModule(
 	addressForLogging common.Address,
 	codehash common.Hash,
 	wasm []byte,
@@ -90,7 +91,7 @@ func activateProgramInternal(
 	arbosVersionForGas uint64,
 	debug bool,
 	gasLeft *uint64,
-) (*activationInfo, map[ethdb.WasmTarget][]byte, error) {
+) (*activationInfo, []byte, error) {
 	output := &rustBytes{}
 	moduleHash := &bytes32{}
 	stylusData := &C.StylusData{}
@@ -119,69 +120,120 @@ func activateProgramInternal(
 		}
 		return nil, nil, err
 	}
-	hash := bytes32ToHash(moduleHash)
-	targets := db.Database().WasmTargets()
+	info := &activationInfo{
+		moduleHash:    bytes32ToHash(moduleHash),
+		initGas:       uint16(stylusData.init_cost),
+		cachedInitGas: uint16(stylusData.cached_init_cost),
+		asmEstimate:   uint32(stylusData.asm_estimate),
+		footprint:     uint16(stylusData.footprint),
+	}
+	return info, module, nil
+}
+
+func compileNative(
+	wasm []byte,
+	stylusVersion uint16,
+	debug bool,
+	target ethdb.WasmTarget,
+) ([]byte, error) {
+	output := &rustBytes{}
+	status_asm := C.stylus_compile(
+		goSlice(wasm),
+		u16(stylusVersion),
+		cbool(debug),
+		goSlice([]byte(target)),
+		output,
+	)
+	asm := rustBytesIntoBytes(output)
+	if status_asm != 0 {
+		return nil, fmt.Errorf("%w: %s", ErrProgramActivation, string(asm))
+	}
+	return asm, nil
+}
+
+func activateProgramInternal(
+	addressForLogging common.Address,
+	codehash common.Hash,
+	wasm []byte,
+	page_limit uint16,
+	stylusVersion uint16,
+	arbosVersionForGas uint64,
+	debug bool,
+	gasLeft *uint64,
+	targets []ethdb.WasmTarget,
+	moduleActivationMandatory bool,
+) (*activationInfo, map[ethdb.WasmTarget][]byte, error) {
+	var wavmFound bool
+	var nativeTargets []ethdb.WasmTarget
+	for _, target := range targets {
+		if target == rawdb.TargetWavm {
+			wavmFound = true
+		} else {
+			nativeTargets = append(nativeTargets, target)
+		}
+	}
 	type result struct {
 		target ethdb.WasmTarget
 		asm    []byte
 		err    error
 	}
-	results := make(chan result, len(targets))
-	for _, target := range targets {
-		target := target
-		if target == rawdb.TargetWavm {
-			results <- result{target, module, nil}
-		} else {
-			go func() {
-				output := &rustBytes{}
-				status_asm := C.stylus_compile(
-					goSlice(wasm),
-					u16(stylusVersion),
-					cbool(debug),
-					goSlice([]byte(target)),
-					output,
-				)
-				asm := rustBytesIntoBytes(output)
-				if status_asm != 0 {
-					results <- result{target, nil, fmt.Errorf("%w: %s", ErrProgramActivation, string(asm))}
-					return
-				}
-				results <- result{target, asm, nil}
-			}()
+	results := make(chan result)
+	// info will be set in separate thread, make sure to wait before reading
+	var info *activationInfo
+	asmMap := make(map[ethdb.WasmTarget][]byte, len(nativeTargets)+1)
+	if moduleActivationMandatory || wavmFound {
+		go func() {
+			var err error
+			var module []byte
+			info, module, err = activateModule(addressForLogging, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, gasLeft)
+			results <- result{rawdb.TargetWavm, module, err}
+		}()
+	}
+	if moduleActivationMandatory {
+		// wait for the module activation before starting compilation for other targets
+		res := <-results
+		if res.err != nil {
+			return nil, nil, res.err
+		} else if wavmFound {
+			asmMap[res.target] = res.asm
 		}
 	}
-	asmMap := make(map[ethdb.WasmTarget][]byte, len(targets))
-	for range targets {
+	for _, target := range nativeTargets {
+		target := target
+		go func() {
+			asm, err := compileNative(wasm, stylusVersion, debug, target)
+			results <- result{target, asm, err}
+		}()
+	}
+	expectedResults := len(nativeTargets)
+	if !moduleActivationMandatory && wavmFound {
+		// we didn't wait for module activation result, so wait for it too
+		expectedResults++
+	}
+	var err error
+	for i := 0; i < expectedResults; i++ {
 		res := <-results
 		if res.err != nil {
-			err = errors.Join(res.err, err)
+			err = errors.Join(res.err, fmt.Errorf("%s:%w", res.target, err))
 		} else {
 			asmMap[res.target] = res.asm
 		}
 	}
-	if err != nil {
+	if err != nil && moduleActivationMandatory {
 		log.Error(
 			"Compilation failed for one or more targets despite activation succeeding",
 			"address", addressForLogging,
-			"codeHash", codeHash,
-			"moduleHash", hash,
+			"codehash", codehash,
+			"moduleHash", info.moduleHash,
 			"targets", targets,
 			"err", err,
 		)
 		panic(fmt.Sprintf("Compilation of %v failed for one or more targets despite activation succeeding: %v", addressForLogging, err))
 	}
-
-	info := &activationInfo{
-		moduleHash:    hash,
-		initGas:       uint16(stylusData.init_cost),
-		cachedInitGas: uint16(stylusData.cached_init_cost),
-		asmEstimate:   uint32(stylusData.asm_estimate),
-		footprint:     uint16(stylusData.footprint),
-	}
 	return info, asmMap, err
 }
 
-func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codeHash common.Hash, pagelimit uint16, time uint64, debugMode bool, program Program) ([]byte, error) {
+func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codehash common.Hash, pagelimit uint16, time uint64, debugMode bool, program Program) ([]byte, error) {
 	localTarget := rawdb.LocalTarget()
 	localAsm, err := statedb.TryGetActivatedAsm(localTarget, moduleHash)
 	if err == nil && len(localAsm) > 0 {
@@ -199,14 +251,16 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 	zeroArbosVersion := uint64(0)
 	zeroGas := uint64(0)
 
+	targets := statedb.Database().WasmTargets()
 	// we know program is activated, so it must be in correct version and not use too much memory
-	info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
+	moduleActivationMandatory := false
+	info, asmMap, err := activateProgramInternal(addressForLogging, codehash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas, targets, moduleActivationMandatory)
 	if err != nil {
 		log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err)
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
 	}
 
-	if info.moduleHash != moduleHash {
+	if info != nil && info.moduleHash != moduleHash {
 		log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "got", info.moduleHash)
 		return nil, fmt.Errorf("failed to reactivate program. address: %v, expected ModuleHash: %v", addressForLogging, moduleHash)
 	}
@@ -223,7 +277,7 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 	} else {
 		// program activated recently, possibly in this eth_call
 		// store it to statedb. It will be stored to database if statedb is commited
-		statedb.ActivateWasm(info.moduleHash, asmMap)
+		statedb.ActivateWasm(moduleHash, asmMap)
 	}
 	asm, exists := asmMap[localTarget]
 	if !exists {
@@ -302,10 +356,10 @@ func handleReqImpl(apiId usize, req_type u32, data *rustSlice, costPtr *u64, out
 
 // Caches a program in Rust. We write a record so that we can undo on revert.
 // For gas estimation and eth_call, we ignore permanent updates and rely on Rust's LRU.
-func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codeHash common.Hash, params *StylusParams, debug bool, time uint64, runMode core.MessageRunMode) {
+func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codehash common.Hash, params *StylusParams, debug bool, time uint64, runMode core.MessageRunMode) {
 	if runMode == core.MessageCommitMode {
 		// address is only used for logging
-		asm, err := getLocalAsm(db, module, addressForLogging, code, codeHash, params.PageLimit, time, debug, program)
+		asm, err := getLocalAsm(db, module, addressForLogging, code, codehash, params.PageLimit, time, debug, program)
 		if err != nil {
 			panic("unable to recreate wasm")
 		}
diff --git a/arbos/programs/native_api.go b/arbos/programs/native_api.go
index ab15800ef9..ad8cc0477b 100644
--- a/arbos/programs/native_api.go
+++ b/arbos/programs/native_api.go
@@ -25,11 +25,11 @@ import "C"
 
 import (
 	"runtime"
+	"strconv"
 	"sync"
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -69,11 +69,11 @@ func newApi(
 func getApi(id usize) NativeApi {
 	any, ok := apiObjects.Load(uintptr(id))
 	if !ok {
-		log.Crit("failed to load stylus Go API", "id", id)
+		panic("failed to load stylus Go API id: " + strconv.Itoa(int(id)))
 	}
 	api, ok := any.(NativeApi)
 	if !ok {
-		log.Crit("wrong type for stylus Go API", "id", id)
+		panic("wrong type for stylus Go API id: " + strconv.Itoa(int(id)))
 	}
 	return api
 }
diff --git a/arbos/programs/programs.go b/arbos/programs/programs.go
index 06ba6ead8c..c2fc1f68ad 100644
--- a/arbos/programs/programs.go
+++ b/arbos/programs/programs.go
@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	gethParams "github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbcompress"
@@ -163,6 +164,21 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, arbosVers
 	return stylusVersion, codeHash, info.moduleHash, dataFee, false, p.setProgram(codeHash, programData)
 }
 
+func runModeToString(runMode core.MessageRunMode) string {
+	switch runMode {
+	case core.MessageCommitMode:
+		return "commit_runmode"
+	case core.MessageGasEstimationMode:
+		return "gas_estimation_runmode"
+	case core.MessageEthcallMode:
+		return "eth_call_runmode"
+	case core.MessageReplayMode:
+		return "replay_runmode"
+	default:
+		return "unknown_runmode"
+	}
+}
+
 func (p Programs) CallProgram(
 	scope *vm.ScopeContext,
 	statedb vm.StateDB,
@@ -171,7 +187,7 @@ func (p Programs) CallProgram(
 	tracingInfo *util.TracingInfo,
 	calldata []byte,
 	reentrant bool,
-	runmode core.MessageRunMode,
+	runMode core.MessageRunMode,
 ) ([]byte, error) {
 	evm := interpreter.Evm()
 	contract := scope.Contract
@@ -219,8 +235,7 @@ func (p Programs) CallProgram(
 
 	localAsm, err := getLocalAsm(statedb, moduleHash, contract.Address(), contract.Code, contract.CodeHash, params.PageLimit, evm.Context.Time, debugMode, program)
 	if err != nil {
-		log.Crit("failed to get local wasm for activated program", "program", contract.Address())
-		return nil, err
+		panic("failed to get local wasm for activated program: " + contract.Address().Hex())
 	}
 
 	evmData := &EvmData{
@@ -247,20 +262,26 @@ func (p Programs) CallProgram(
 		address = *contract.CodeAddr
 	}
 	var arbos_tag uint32
-	if runmode == core.MessageCommitMode {
+	if runMode == core.MessageCommitMode {
 		arbos_tag = statedb.Database().WasmCacheTag()
 	}
+
+	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/program_calls/%s", runModeToString(runMode)), nil).Inc(1)
 	ret, err := callProgram(address, moduleHash, localAsm, scope, interpreter, tracingInfo, calldata, evmData, goParams, model, arbos_tag)
 	if len(ret) > 0 && arbosVersion >= gethParams.ArbosVersion_StylusFixes {
 		// Ensure that return data costs as least as much as it would in the EVM.
 		evmCost := evmMemoryCost(uint64(len(ret)))
 		if startingGas < evmCost {
 			contract.Gas = 0
+			// #nosec G115
+			metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runModeToString(runMode)), nil).Inc(int64(startingGas))
 			return nil, vm.ErrOutOfGas
 		}
 		maxGasToReturn := startingGas - evmCost
 		contract.Gas = am.MinInt(contract.Gas, maxGasToReturn)
 	}
+	// #nosec G115
+	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runModeToString(runMode)), nil).Inc(int64(startingGas - contract.Gas))
 	return ret, err
 }
 
diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go
index c2d1aa65b0..1393752b72 100644
--- a/arbos/programs/wasmstorehelper.go
+++ b/arbos/programs/wasmstorehelper.go
@@ -62,7 +62,8 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash
 
 	// We know program is activated, so it must be in correct version and not use too much memory
 	// Empty program address is supplied because we dont have access to this during rebuilding of wasm store
-	info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
+	moduleActivationMandatory := false
+	info, asmMap, err := activateProgramInternal(common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, zeroArbosVersion, debugMode, &zeroGas, targets, moduleActivationMandatory)
 	if err != nil {
 		log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err)
 		return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err)
diff --git a/arbos/util/transfer.go b/arbos/util/transfer.go
index 0b61868abe..55281fa284 100644
--- a/arbos/util/transfer.go
+++ b/arbos/util/transfer.go
@@ -67,7 +67,7 @@ func TransferBalance(
 		if arbmath.BigLessThan(balance.ToBig(), amount) {
 			return fmt.Errorf("%w: addr %v have %v want %v", vm.ErrInsufficientBalance, *from, balance, amount)
 		}
-		if evm.Context.ArbOSVersion < params.ArbosVersion_30 && amount.Sign() == 0 {
+		if evm.Context.ArbOSVersion < params.ArbosVersion_Stylus && amount.Sign() == 0 {
 			evm.StateDB.CreateZombieIfDeleted(*from)
 		}
 		evm.StateDB.SubBalance(*from, uint256.MustFromBig(amount), tracing.BalanceChangeTransfer)
diff --git a/arbstate/inbox.go b/arbstate/inbox.go
index b58a7420b7..5539a75ce1 100644
--- a/arbstate/inbox.go
+++ b/arbstate/inbox.go
@@ -85,11 +85,11 @@ func parseSequencerMessage(ctx context.Context, batchNum uint64, batchBlockHash
 					// Matches the way keyset validation was done inside DAS readers i.e logging the error
 					//  But other daproviders might just want to return the error
 					if errors.Is(err, daprovider.ErrSeqMsgValidation) && daprovider.IsDASMessageHeaderByte(payload[0]) {
-						logLevel := log.Error
 						if keysetValidationMode == daprovider.KeysetPanicIfInvalid {
-							logLevel = log.Crit
+							panic(err.Error())
+						} else {
+							log.Error(err.Error())
 						}
-						logLevel(err.Error())
 					} else {
 						return nil, err
 					}
diff --git a/bold b/bold
index d0a87de774..60b5e36725 160000
--- a/bold
+++ b/bold
@@ -1 +1 @@
-Subproject commit d0a87de774aecfa97161efd1b0a924d4d5fbcf74
+Subproject commit 60b5e36725da9551b005d6171e75eda30a63d49a
diff --git a/execution/gethexec/api.go b/execution/gethexec/api.go
index 713d1496f9..699aa081b5 100644
--- a/execution/gethexec/api.go
+++ b/execution/gethexec/api.go
@@ -17,6 +17,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 
 	"github.com/offchainlabs/nitro/arbos/arbosState"
@@ -285,14 +286,16 @@ func stateAndHeader(blockchain *core.BlockChain, block uint64) (*arbosState.Arbo
 type ArbTraceForwarderAPI struct {
 	fallbackClientUrl     string
 	fallbackClientTimeout time.Duration
+	blockchainConfig      *params.ChainConfig
 
 	initialized    atomic.Bool
 	mutex          sync.Mutex
 	fallbackClient types.FallbackClient
 }
 
-func NewArbTraceForwarderAPI(fallbackClientUrl string, fallbackClientTimeout time.Duration) *ArbTraceForwarderAPI {
+func NewArbTraceForwarderAPI(blockchainConfig *params.ChainConfig, fallbackClientUrl string, fallbackClientTimeout time.Duration) *ArbTraceForwarderAPI {
 	return &ArbTraceForwarderAPI{
+		blockchainConfig:      blockchainConfig,
 		fallbackClientUrl:     fallbackClientUrl,
 		fallbackClientTimeout: fallbackClientTimeout,
 	}
@@ -332,16 +335,45 @@ func (api *ArbTraceForwarderAPI) forward(ctx context.Context, method string, arg
 	return resp, nil
 }
 
-func (api *ArbTraceForwarderAPI) Call(ctx context.Context, callArgs json.RawMessage, traceTypes json.RawMessage, blockNum json.RawMessage) (*json.RawMessage, error) {
-	return api.forward(ctx, "arbtrace_call", callArgs, traceTypes, blockNum)
+func (api *ArbTraceForwarderAPI) blockSupportedByClassicNode(blockNumOrHash json.RawMessage) error {
+	var bnh rpc.BlockNumberOrHash
+	err := bnh.UnmarshalJSON(blockNumOrHash)
+	if err != nil {
+		return err
+	}
+	blockNum, isNum := bnh.Number()
+	if !isNum {
+		return nil
+	}
+	// #nosec G115
+	if blockNum < 0 || blockNum > rpc.BlockNumber(api.blockchainConfig.ArbitrumChainParams.GenesisBlockNum) {
+		return fmt.Errorf("block number %v is not supported by classic node", blockNum)
+	}
+	return nil
 }
 
-func (api *ArbTraceForwarderAPI) CallMany(ctx context.Context, calls json.RawMessage, blockNum json.RawMessage) (*json.RawMessage, error) {
-	return api.forward(ctx, "arbtrace_callMany", calls, blockNum)
+func (api *ArbTraceForwarderAPI) Call(ctx context.Context, callArgs json.RawMessage, traceTypes json.RawMessage, blockNumOrHash json.RawMessage) (*json.RawMessage, error) {
+	err := api.blockSupportedByClassicNode(blockNumOrHash)
+	if err != nil {
+		return nil, err
+	}
+	return api.forward(ctx, "arbtrace_call", callArgs, traceTypes, blockNumOrHash)
 }
 
-func (api *ArbTraceForwarderAPI) ReplayBlockTransactions(ctx context.Context, blockNum json.RawMessage, traceTypes json.RawMessage) (*json.RawMessage, error) {
-	return api.forward(ctx, "arbtrace_replayBlockTransactions", blockNum, traceTypes)
+func (api *ArbTraceForwarderAPI) CallMany(ctx context.Context, calls json.RawMessage, blockNumOrHash json.RawMessage) (*json.RawMessage, error) {
+	err := api.blockSupportedByClassicNode(blockNumOrHash)
+	if err != nil {
+		return nil, err
+	}
+	return api.forward(ctx, "arbtrace_callMany", calls, blockNumOrHash)
+}
+
+func (api *ArbTraceForwarderAPI) ReplayBlockTransactions(ctx context.Context, blockNumOrHash json.RawMessage, traceTypes json.RawMessage) (*json.RawMessage, error) {
+	err := api.blockSupportedByClassicNode(blockNumOrHash)
+	if err != nil {
+		return nil, err
+	}
+	return api.forward(ctx, "arbtrace_replayBlockTransactions", blockNumOrHash, traceTypes)
 }
 
 func (api *ArbTraceForwarderAPI) ReplayTransaction(ctx context.Context, txHash json.RawMessage, traceTypes json.RawMessage) (*json.RawMessage, error) {
@@ -356,8 +388,12 @@ func (api *ArbTraceForwarderAPI) Get(ctx context.Context, txHash json.RawMessage
 	return api.forward(ctx, "arbtrace_get", txHash, path)
 }
 
-func (api *ArbTraceForwarderAPI) Block(ctx context.Context, blockNum json.RawMessage) (*json.RawMessage, error) {
-	return api.forward(ctx, "arbtrace_block", blockNum)
+func (api *ArbTraceForwarderAPI) Block(ctx context.Context, blockNumOrHash json.RawMessage) (*json.RawMessage, error) {
+	err := api.blockSupportedByClassicNode(blockNumOrHash)
+	if err != nil {
+		return nil, err
+	}
+	return api.forward(ctx, "arbtrace_block", blockNumOrHash)
 }
 
 func (api *ArbTraceForwarderAPI) Filter(ctx context.Context, filter json.RawMessage) (*json.RawMessage, error) {
diff --git a/execution/gethexec/node.go b/execution/gethexec/node.go
index 11d173a21e..5030de0cfa 100644
--- a/execution/gethexec/node.go
+++ b/execution/gethexec/node.go
@@ -55,9 +55,6 @@ func (c *StylusTargetConfig) Validate() error {
 		}
 		targetsSet[target] = true
 	}
-	if !targetsSet[rawdb.TargetWavm] {
-		return fmt.Errorf("%s target not found in archs list, archs: %v", rawdb.TargetWavm, c.ExtraArchs)
-	}
 	targetsSet[rawdb.LocalTarget()] = true
 	targets := make([]ethdb.WasmTarget, 0, len(c.ExtraArchs)+1)
 	for target := range targetsSet {
@@ -284,6 +281,7 @@ func CreateExecutionNode(
 		Namespace: "arbtrace",
 		Version:   "1.0",
 		Service: NewArbTraceForwarderAPI(
+			l2BlockChain.Config(),
 			config.RPC.ClassicRedirect,
 			config.RPC.ClassicRedirectTimeout,
 		),
diff --git a/go-ethereum b/go-ethereum
index 26b4dff616..dd32b782ed 160000
--- a/go-ethereum
+++ b/go-ethereum
@@ -1 +1 @@
-Subproject commit 26b4dff6165650b6963fb1b6f88958c29c059214
+Subproject commit dd32b782ed255c1ac20ed5beee11dd6a821f9be2
diff --git a/go.mod b/go.mod
index 7a48b0520d..cfcca3628b 100644
--- a/go.mod
+++ b/go.mod
@@ -20,6 +20,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.27
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.64.1
 	github.com/cavaliergopher/grab/v3 v3.0.1
+	github.com/ccoveille/go-safecast v1.1.0
 	github.com/cockroachdb/pebble v1.1.0
 	github.com/codeclysm/extract/v3 v3.0.2
 	github.com/dgraph-io/badger/v4 v4.2.0
@@ -46,9 +47,9 @@ require (
 	github.com/spf13/pflag v1.0.5
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
 	github.com/wealdtech/go-merkletree v1.0.0
-	golang.org/x/crypto v0.24.0
-	golang.org/x/sys v0.21.0
-	golang.org/x/term v0.21.0
+	golang.org/x/crypto v0.31.0
+	golang.org/x/sys v0.28.0
+	golang.org/x/term v0.27.0
 	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d
 	google.golang.org/api v0.187.0
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0
@@ -60,7 +61,6 @@ require (
 	cloud.google.com/go/auth/oauth2adapt v0.2.2 // indirect
 	cloud.google.com/go/compute/metadata v0.3.0 // indirect
 	cloud.google.com/go/iam v1.1.8 // indirect
-	github.com/ccoveille/go-safecast v1.1.0 // indirect
 	github.com/felixge/httpsnoop v1.0.4 // indirect
 	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
@@ -195,8 +195,8 @@ require (
 	golang.org/x/mod v0.17.0 // indirect
 	golang.org/x/net v0.26.0 // indirect
 	golang.org/x/oauth2 v0.22.0
-	golang.org/x/sync v0.8.0
-	golang.org/x/text v0.16.0 // indirect
+	golang.org/x/sync v0.10.0
+	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
diff --git a/go.sum b/go.sum
index 55ad86267a..01b58980dd 100644
--- a/go.sum
+++ b/go.sum
@@ -535,8 +535,8 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
+golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ=
 golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE=
@@ -580,8 +580,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -614,14 +614,14 @@ golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
+golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20181227161524-e6919f6577db/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -631,8 +631,8 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
+golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
 golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
diff --git a/precompiles/context.go b/precompiles/context.go
index 670ffa7443..86e56ffbff 100644
--- a/precompiles/context.go
+++ b/precompiles/context.go
@@ -9,7 +9,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/offchainlabs/nitro/arbos"
 	"github.com/offchainlabs/nitro/arbos/arbosState"
@@ -58,7 +57,7 @@ func (c *Context) GasLeft() *uint64 {
 }
 
 func (c *Context) Restrict(err error) {
-	log.Crit("A metered burner was used for access-controlled work", "error", err)
+	panic("A metered burner was used for access-controlled work :" + err.Error())
 }
 
 func (c *Context) HandleError(err error) error {
@@ -88,13 +87,13 @@ func testContext(caller addr, evm mech) *Context {
 	}
 	state, err := arbosState.OpenArbosState(evm.StateDB, burn.NewSystemBurner(tracingInfo, false))
 	if err != nil {
-		log.Crit("unable to open arbos state", "error", err)
+		panic("unable to open arbos state :" + err.Error())
 	}
 	ctx.State = state
 	var ok bool
 	ctx.txProcessor, ok = evm.ProcessingHook.(*arbos.TxProcessor)
 	if !ok {
-		log.Crit("must have tx processor")
+		panic("must have tx processor")
 	}
 	return ctx
 }
diff --git a/precompiles/precompile.go b/precompiles/precompile.go
index 54d18a0cc9..7ca9d409c6 100644
--- a/precompiles/precompile.go
+++ b/precompiles/precompile.go
@@ -120,7 +120,7 @@ func (e *SolError) Error() string {
 func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Precompile) {
 	source, err := abi.JSON(strings.NewReader(metadata.ABI))
 	if err != nil {
-		log.Crit("Bad ABI")
+		panic("Bad ABI")
 	}
 
 	implementerType := reflect.TypeOf(implementer)
@@ -128,12 +128,12 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 
 	_, ok := implementerType.Elem().FieldByName("Address")
 	if !ok {
-		log.Crit("Implementer for precompile ", contract, " is missing an Address field")
+		panic("Implementer for precompile " + contract + " is missing an Address field")
 	}
 
 	address, ok := reflect.ValueOf(implementer).Elem().FieldByName("Address").Interface().(addr)
 	if !ok {
-		log.Crit("Implementer for precompile ", contract, "'s Address field has the wrong type")
+		panic("Implementer for precompile " + contract + "'s Address field has the wrong type")
 	}
 
 	gethAbiFuncTypeEquality := func(actual, geth reflect.Type) bool {
@@ -167,7 +167,7 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 		name = capitalize + name[1:]
 
 		if len(method.ID) != 4 {
-			log.Crit("Method ID isn't 4 bytes")
+			panic("Method ID isn't 4 bytes")
 		}
 		id := *(*[4]byte)(method.ID)
 
@@ -175,7 +175,7 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 
 		handler, ok := implementerType.MethodByName(name)
 		if !ok {
-			log.Crit("Precompile " + contract + " must implement " + name)
+			panic("Precompile " + contract + " must implement " + name)
 		}
 
 		var needs = []reflect.Type{
@@ -199,7 +199,7 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 			needs = append(needs, reflect.TypeOf(&big.Int{}))
 			purity = payable
 		default:
-			log.Crit("Unknown state mutability ", method.StateMutability)
+			panic("Unknown state mutability " + method.StateMutability)
 		}
 
 		for _, arg := range method.Inputs {
@@ -215,10 +215,9 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 		expectedHandlerType := reflect.FuncOf(needs, outputs, false)
 
 		if !gethAbiFuncTypeEquality(handler.Type, expectedHandlerType) {
-			log.Crit(
-				"Precompile "+contract+"'s "+name+"'s implementer has the wrong type\n",
-				"\texpected:\t", expectedHandlerType, "\n\tbut have:\t", handler.Type,
-			)
+			panic(
+				"Precompile " + contract + "'s " + name + "'s implementer has the wrong type\n" +
+					"\texpected:\t" + expectedHandlerType.String() + "\n\tbut have:\t" + handler.Type.String())
 		}
 
 		method := PrecompileMethod{
@@ -237,7 +236,7 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 		method := implementerType.Method(i)
 		name := method.Name
 		if method.IsExported() && methodsByName[name] == nil {
-			log.Crit(contract + " is missing a solidity interface for " + name)
+			panic(contract + " is missing a solidity interface for " + name)
 		}
 	}
 
@@ -269,11 +268,10 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 			if arg.Indexed {
 				_, ok := supportedIndices[arg.Type.String()]
 				if !ok {
-					log.Crit(
-						"Please change the solidity for precompile ", contract,
-						"'s event ", name, ":\n\tEvent indices of type ",
-						arg.Type.String(), " are not supported",
-					)
+					panic(
+						"Please change the solidity for precompile " + contract +
+							"'s event " + name + ":\n\tEvent indices of type " +
+							arg.Type.String() + " are not supported")
 				}
 			}
 		}
@@ -288,23 +286,21 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 
 		field, ok := implementerType.Elem().FieldByName(name)
 		if !ok {
-			log.Crit(missing, "event ", name, " of type\n\t", expectedFieldType)
+			panic(missing + "event " + name + " of type\n\t" + expectedFieldType.String())
 		}
 		costField, ok := implementerType.Elem().FieldByName(name + "GasCost")
 		if !ok {
-			log.Crit(missing, "event ", name, "'s GasCost of type\n\t", expectedCostType)
+			panic(missing + "event " + name + "'s GasCost of type\n\t" + expectedCostType.String())
 		}
 		if !gethAbiFuncTypeEquality(field.Type, expectedFieldType) {
-			log.Crit(
-				context, "'s field for event ", name, " has the wrong type\n",
-				"\texpected:\t", expectedFieldType, "\n\tbut have:\t", field.Type,
-			)
+			panic(
+				context + "'s field for event " + name + " has the wrong type\n" +
+					"\texpected:\t" + expectedFieldType.String() + "\n\tbut have:\t" + field.Type.String())
 		}
 		if !gethAbiFuncTypeEquality(costField.Type, expectedCostType) {
-			log.Crit(
-				context, "'s field for event ", name, "GasCost has the wrong type\n",
-				"\texpected:\t", expectedCostType, "\n\tbut have:\t", costField.Type,
-			)
+			panic(
+				context + "'s field for event " + name + "GasCost has the wrong type\n" +
+					"\texpected:\t" + expectedCostType.String() + "\n\tbut have:\t" + costField.Type.String())
 		}
 
 		structFields := reflect.ValueOf(implementer).Elem()
@@ -464,13 +460,12 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 
 		field, ok := implementerType.Elem().FieldByName(name + "Error")
 		if !ok {
-			log.Crit(missing, "custom error ", name, "Error of type\n\t", expectedFieldType)
+			panic(missing + "custom error " + name + "Error of type\n\t" + expectedFieldType.String())
 		}
 		if field.Type != expectedFieldType {
-			log.Crit(
-				context, "'s field for error ", name, "Error has the wrong type\n",
-				"\texpected:\t", expectedFieldType, "\n\tbut have:\t", field.Type,
-			)
+			panic(
+				context + "'s field for error " + name + "Error has the wrong type\n" +
+					"\texpected:\t" + expectedFieldType.String() + "\n\tbut have:\t" + field.Type.String())
 		}
 
 		structFields := reflect.ValueOf(implementer).Elem()
@@ -756,7 +751,7 @@ func (p *Precompile) Call(
 		reflectArgs = append(reflectArgs, reflect.ValueOf(evm))
 		reflectArgs = append(reflectArgs, reflect.ValueOf(value))
 	default:
-		log.Crit("Unknown state mutability ", method.purity)
+		panic("Unknown state mutability " + strconv.Itoa(int(method.purity)))
 	}
 
 	args, err := method.template.Inputs.Unpack(input[4:])
diff --git a/precompiles/precompile_test.go b/precompiles/precompile_test.go
index 75fed711eb..183ec1f083 100644
--- a/precompiles/precompile_test.go
+++ b/precompiles/precompile_test.go
@@ -5,15 +5,12 @@ package precompiles
 
 import (
 	"fmt"
-	"io"
 	"math/big"
-	"os"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbos/storage"
@@ -183,12 +180,6 @@ func TestEventCosts(t *testing.T) {
 }
 
 func TestPrecompilesPerArbosVersion(t *testing.T) {
-	// Set up a logger in case log.Crit is called by Precompiles()
-	glogger := log.NewGlogHandler(
-		log.NewTerminalHandler(io.Writer(os.Stderr), false))
-	glogger.Verbosity(log.LevelWarn)
-	log.SetDefault(log.NewLogger(glogger))
-
 	expectedNewMethodsPerArbosVersion := map[uint64]int{
 		0:                      89,
 		params.ArbosVersion_5:  3,
diff --git a/staker/bold/bold_staker.go b/staker/bold/bold_staker.go
index 063f7b9719..7a21f9e6b7 100644
--- a/staker/bold/bold_staker.go
+++ b/staker/bold/bold_staker.go
@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"strings"
 	"time"
 
 	flag "github.com/spf13/pflag"
@@ -57,16 +58,23 @@ type BoldConfig struct {
 	// How often to scan for newly created assertions onchain.
 	AssertionScanningInterval time.Duration `koanf:"assertion-scanning-interval"`
 	// How often to confirm assertions onchain.
-	AssertionConfirmingInterval         time.Duration       `koanf:"assertion-confirming-interval"`
-	API                                 bool                `koanf:"api"`
-	APIHost                             string              `koanf:"api-host"`
-	APIPort                             uint16              `koanf:"api-port"`
-	APIDBPath                           string              `koanf:"api-db-path"`
-	TrackChallengeParentAssertionHashes []string            `koanf:"track-challenge-parent-assertion-hashes"`
-	CheckStakerSwitchInterval           time.Duration       `koanf:"check-staker-switch-interval"`
-	StateProviderConfig                 StateProviderConfig `koanf:"state-provider-config"`
-	StartValidationFromStaked           bool                `koanf:"start-validation-from-staked"`
-	strategy                            legacystaker.StakerStrategy
+	AssertionConfirmingInterval         time.Duration          `koanf:"assertion-confirming-interval"`
+	API                                 bool                   `koanf:"api"`
+	APIHost                             string                 `koanf:"api-host"`
+	APIPort                             uint16                 `koanf:"api-port"`
+	APIDBPath                           string                 `koanf:"api-db-path"`
+	TrackChallengeParentAssertionHashes []string               `koanf:"track-challenge-parent-assertion-hashes"`
+	CheckStakerSwitchInterval           time.Duration          `koanf:"check-staker-switch-interval"`
+	StateProviderConfig                 StateProviderConfig    `koanf:"state-provider-config"`
+	StartValidationFromStaked           bool                   `koanf:"start-validation-from-staked"`
+	AutoDeposit                         bool                   `koanf:"auto-deposit"`
+	AutoIncreaseAllowance               bool                   `koanf:"auto-increase-allowance"`
+	DelegatedStaking                    DelegatedStakingConfig `koanf:"delegated-staking"`
+	RPCBlockNumber                      string                 `koanf:"rpc-block-number"`
+	// How long to wait since parent assertion was created to post a new assertion
+	MinimumGapToParentAssertion time.Duration `koanf:"minimum-gap-to-parent-assertion"`
+	strategy                    legacystaker.StakerStrategy
+	blockNum                    rpc.BlockNumber
 }
 
 func (c *BoldConfig) Validate() error {
@@ -75,9 +83,31 @@ func (c *BoldConfig) Validate() error {
 		return err
 	}
 	c.strategy = strategy
+	var blockNum rpc.BlockNumber
+	switch strings.ToLower(c.RPCBlockNumber) {
+	case "safe":
+		blockNum = rpc.SafeBlockNumber
+	case "finalized":
+		blockNum = rpc.FinalizedBlockNumber
+	case "latest":
+		blockNum = rpc.LatestBlockNumber
+	default:
+		return fmt.Errorf("unknown rpc block number \"%v\", expected either latest, safe, or finalized", c.RPCBlockNumber)
+	}
+	c.blockNum = blockNum
 	return nil
 }
 
+type DelegatedStakingConfig struct {
+	Enable                  bool   `koanf:"enable"`
+	CustomWithdrawalAddress string `koanf:"custom-withdrawal-address"`
+}
+
+var DefaultDelegatedStakingConfig = DelegatedStakingConfig{
+	Enable:                  false,
+	CustomWithdrawalAddress: "",
+}
+
 type StateProviderConfig struct {
 	// A name identifier for the validator for cosmetic purposes.
 	ValidatorName      string `koanf:"validator-name"`
@@ -98,6 +128,7 @@ var DefaultBoldConfig = BoldConfig{
 	AssertionPostingInterval:            time.Minute * 15,
 	AssertionScanningInterval:           time.Minute,
 	AssertionConfirmingInterval:         time.Minute,
+	MinimumGapToParentAssertion:         time.Minute, // Correct default?
 	API:                                 false,
 	APIHost:                             "127.0.0.1",
 	APIPort:                             9393,
@@ -106,6 +137,10 @@ var DefaultBoldConfig = BoldConfig{
 	CheckStakerSwitchInterval:           time.Minute, // Every minute, check if the Nitro node staker should switch to using BOLD.
 	StateProviderConfig:                 DefaultStateProviderConfig,
 	StartValidationFromStaked:           true,
+	AutoDeposit:                         true,
+	AutoIncreaseAllowance:               true,
+	DelegatedStaking:                    DefaultDelegatedStakingConfig,
+	RPCBlockNumber:                      "finalized",
 }
 
 var BoldModes = map[legacystaker.StakerStrategy]boldtypes.Mode{
@@ -118,9 +153,11 @@ var BoldModes = map[legacystaker.StakerStrategy]boldtypes.Mode{
 func BoldConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Bool(prefix+".enable", DefaultBoldConfig.Enable, "enable bold challenge protocol")
 	f.String(prefix+".strategy", DefaultBoldConfig.Strategy, "define the bold validator staker strategy, either watchtower, defensive, stakeLatest, or makeNodes")
+	f.String(prefix+".rpc-block-number", DefaultBoldConfig.RPCBlockNumber, "define the block number to use for reading data onchain, either latest, safe, or finalized")
 	f.Duration(prefix+".assertion-posting-interval", DefaultBoldConfig.AssertionPostingInterval, "assertion posting interval")
 	f.Duration(prefix+".assertion-scanning-interval", DefaultBoldConfig.AssertionScanningInterval, "scan assertion interval")
 	f.Duration(prefix+".assertion-confirming-interval", DefaultBoldConfig.AssertionConfirmingInterval, "confirm assertion interval")
+	f.Duration(prefix+".minimum-gap-to-parent-assertion", DefaultBoldConfig.MinimumGapToParentAssertion, "minimum duration to wait since the parent assertion was created to post a new assertion")
 	f.Duration(prefix+".check-staker-switch-interval", DefaultBoldConfig.CheckStakerSwitchInterval, "how often to check if staker can switch to bold")
 	f.Bool(prefix+".api", DefaultBoldConfig.API, "enable api")
 	f.String(prefix+".api-host", DefaultBoldConfig.APIHost, "bold api host")
@@ -129,6 +166,9 @@ func BoldConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.StringSlice(prefix+".track-challenge-parent-assertion-hashes", DefaultBoldConfig.TrackChallengeParentAssertionHashes, "only track challenges/edges with these parent assertion hashes")
 	StateProviderConfigAddOptions(prefix+".state-provider-config", f)
 	f.Bool(prefix+".start-validation-from-staked", DefaultBoldConfig.StartValidationFromStaked, "assume staked nodes are valid")
+	f.Bool(prefix+".auto-deposit", DefaultBoldConfig.AutoDeposit, "auto-deposit stake token whenever making a move in BoLD that does not have enough stake token balance")
+	f.Bool(prefix+".auto-increase-allowance", DefaultBoldConfig.AutoIncreaseAllowance, "auto-increase spending allowance of the stake token by the rollup and challenge manager contracts")
+	DelegatedStakingConfigAddOptions(prefix+".delegated-staking", f)
 }
 
 func StateProviderConfigAddOptions(prefix string, f *flag.FlagSet) {
@@ -137,6 +177,11 @@ func StateProviderConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.String(prefix+".machine-leaves-cache-path", DefaultStateProviderConfig.MachineLeavesCachePath, "path to machine cache")
 }
 
+func DelegatedStakingConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Bool(prefix+".enable", DefaultDelegatedStakingConfig.Enable, "enable delegated staking by having the validator call newStake on startup")
+	f.String(prefix+".custom-withdrawal-address", DefaultDelegatedStakingConfig.CustomWithdrawalAddress, "enable a custom withdrawal address for staking on the rollup contract, useful for delegated stakers")
+}
+
 type BOLDStaker struct {
 	stopwaiter.StopWaiter
 	config                  *BoldConfig
@@ -372,7 +417,25 @@ func newBOLDChallengeManager(
 	if err != nil {
 		return nil, fmt.Errorf("could not create challenge manager bindings: %w", err)
 	}
-	assertionChain, err := solimpl.NewAssertionChain(ctx, rollupAddress, chalManager, txOpts, client, NewDataPosterTransactor(dataPoster))
+	assertionChainOpts := []solimpl.Opt{
+		solimpl.WithRpcHeadBlockNumber(config.blockNum),
+	}
+	if config.DelegatedStaking.Enable && config.DelegatedStaking.CustomWithdrawalAddress != "" {
+		withdrawalAddr := common.HexToAddress(config.DelegatedStaking.CustomWithdrawalAddress)
+		assertionChainOpts = append(assertionChainOpts, solimpl.WithCustomWithdrawalAddress(withdrawalAddr))
+	}
+	if !config.AutoDeposit {
+		assertionChainOpts = append(assertionChainOpts, solimpl.WithoutAutoDeposit())
+	}
+	assertionChain, err := solimpl.NewAssertionChain(
+		ctx,
+		rollupAddress,
+		chalManager,
+		txOpts,
+		client,
+		NewDataPosterTransactor(dataPoster),
+		assertionChainOpts...,
+	)
 	if err != nil {
 		return nil, fmt.Errorf("could not create assertion chain: %w", err)
 	}
@@ -455,6 +518,7 @@ func newBOLDChallengeManager(
 		challengemanager.StackWithPollingInterval(scanningInterval),
 		challengemanager.StackWithPostingInterval(postingInterval),
 		challengemanager.StackWithConfirmationInterval(confirmingInterval),
+		challengemanager.StackWithMinimumGapToParentAssertion(config.MinimumGapToParentAssertion),
 		challengemanager.StackWithTrackChallengeParentAssertionHashes(config.TrackChallengeParentAssertionHashes),
 		challengemanager.StackWithHeaderProvider(l1Reader),
 	}
@@ -462,6 +526,15 @@ func newBOLDChallengeManager(
 		apiAddr := fmt.Sprintf("%s:%d", config.APIHost, config.APIPort)
 		stackOpts = append(stackOpts, challengemanager.StackWithAPIEnabled(apiAddr, apiDBPath))
 	}
+	if !config.AutoDeposit {
+		stackOpts = append(stackOpts, challengemanager.StackWithoutAutoDeposit())
+	}
+	if !config.AutoIncreaseAllowance {
+		stackOpts = append(stackOpts, challengemanager.StackWithoutAutoAllowanceApproval())
+	}
+	if config.DelegatedStaking.Enable {
+		stackOpts = append(stackOpts, challengemanager.StackWithDelegatedStaking())
+	}
 
 	manager, err := challengemanager.NewChallengeStack(
 		assertionChain,
diff --git a/system_tests/bold_challenge_protocol_test.go b/system_tests/bold_challenge_protocol_test.go
index 777817bf3e..83700fc838 100644
--- a/system_tests/bold_challenge_protocol_test.go
+++ b/system_tests/bold_challenge_protocol_test.go
@@ -417,6 +417,7 @@ func testChallengeProtocolBOLD(t *testing.T, spawnerOpts ...server_arb.SpawnerOp
 		challengemanager.StackWithMode(modes.MakeMode),
 		challengemanager.StackWithPostingInterval(time.Second * 3),
 		challengemanager.StackWithPollingInterval(time.Second),
+		challengemanager.StackWithMinimumGapToParentAssertion(0),
 		challengemanager.StackWithAverageBlockCreationTime(time.Second),
 	}
 
diff --git a/system_tests/bold_new_challenge_test.go b/system_tests/bold_new_challenge_test.go
index ad6e44bc71..fae4a57deb 100644
--- a/system_tests/bold_new_challenge_test.go
+++ b/system_tests/bold_new_challenge_test.go
@@ -344,6 +344,7 @@ func startBoldChallengeManager(t *testing.T, ctx context.Context, builder *NodeB
 		challengemanager.StackWithPostingInterval(time.Second * 3),
 		challengemanager.StackWithPollingInterval(time.Second),
 		challengemanager.StackWithAverageBlockCreationTime(time.Second),
+		challengemanager.StackWithMinimumGapToParentAssertion(0),
 	}
 
 	challengeManager, err := challengemanager.NewChallengeStack(
diff --git a/system_tests/common_test.go b/system_tests/common_test.go
index 346a5feec4..d3d4b33ab9 100644
--- a/system_tests/common_test.go
+++ b/system_tests/common_test.go
@@ -1428,6 +1428,7 @@ func createNonL1BlockChainWithStackConfig(
 	if execConfig == nil {
 		execConfig = ExecConfigDefaultTest(t)
 	}
+	Require(t, execConfig.Validate())
 
 	stack, err := node.New(stackConfig)
 	Require(t, err)
@@ -1515,6 +1516,8 @@ func Create2ndNodeWithConfig(
 	if execConfig == nil {
 		execConfig = ExecConfigDefaultNonSequencerTest(t)
 	}
+	Require(t, execConfig.Validate())
+
 	feedErrChan := make(chan error, 10)
 	parentChainRpcClient := parentChainStack.Attach()
 	parentChainClient := ethclient.NewClient(parentChainRpcClient)
@@ -1548,7 +1551,6 @@ func Create2ndNodeWithConfig(
 
 	AddValNodeIfNeeded(t, ctx, nodeConfig, true, "", valnodeConfig.Wasm.RootPath)
 
-	Require(t, execConfig.Validate())
 	Require(t, nodeConfig.Validate())
 	configFetcher := func() *gethexec.Config { return execConfig }
 	currentExec, err := gethexec.CreateExecutionNode(ctx, chainStack, chainDb, blockchain, parentChainClient, configFetcher)
diff --git a/system_tests/overflow_assertions_test.go b/system_tests/overflow_assertions_test.go
index c024a43070..eb2bb01470 100644
--- a/system_tests/overflow_assertions_test.go
+++ b/system_tests/overflow_assertions_test.go
@@ -224,6 +224,7 @@ func TestOverflowAssertions(t *testing.T) {
 		challengemanager.StackWithPostingInterval(time.Second),
 		challengemanager.StackWithPollingInterval(time.Millisecond * 500),
 		challengemanager.StackWithAverageBlockCreationTime(time.Second),
+		challengemanager.StackWithMinimumGapToParentAssertion(0),
 	}
 
 	manager, err := challengemanager.NewChallengeStack(
diff --git a/system_tests/program_test.go b/system_tests/program_test.go
index 5fbb1189c7..053cfe859d 100644
--- a/system_tests/program_test.go
+++ b/system_tests/program_test.go
@@ -59,6 +59,12 @@ func TestProgramKeccak(t *testing.T) {
 			builder.WithExtraArchs(allWasmTargets)
 		})
 	})
+
+	t.Run("WithOnlyLocalTarget", func(t *testing.T) {
+		keccakTest(t, true, func(builder *NodeBuilder) {
+			builder.WithExtraArchs([]string{string(rawdb.LocalTarget())})
+		})
+	})
 }
 
 func keccakTest(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
@@ -69,7 +75,7 @@ func keccakTest(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
 	programAddress := deployWasm(t, ctx, auth, l2client, rustFile("keccak"))
 
 	wasmDb := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().StateCache().WasmStore()
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 
 	wasm, _ := readWasmFile(t, rustFile("keccak"))
 	otherAddressSameCode := deployContract(t, ctx, auth, l2client, wasm)
@@ -82,7 +88,7 @@ func keccakTest(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
 			Fatal(t, "activate should have failed with ProgramUpToDate", err)
 		}
 	})
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 
 	if programAddress == otherAddressSameCode {
 		Fatal(t, "expected to deploy at two separate program addresses")
@@ -164,6 +170,11 @@ func TestProgramActivateTwice(t *testing.T) {
 			builder.WithExtraArchs(allWasmTargets)
 		})
 	})
+	t.Run("WithOnlyLocalTarget", func(t *testing.T) {
+		testActivateTwice(t, true, func(builder *NodeBuilder) {
+			builder.WithExtraArchs([]string{string(rawdb.LocalTarget())})
+		})
+	})
 }
 
 func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
@@ -195,7 +206,7 @@ func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)
 	multiAddr := deployWasm(t, ctx, auth, l2client, rustFile("multicall"))
 
 	wasmDb := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().StateCache().WasmStore()
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 
 	preimage := []byte("it's time to du-du-du-du d-d-d-d-d-d-d de-duplicate")
 
@@ -220,7 +231,7 @@ func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)
 
 	// Calling the contract pre-activation should fail.
 	checkReverts()
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 
 	// mechanisms for creating calldata
 	activateProgram, _ := util.NewCallParser(pgen.ArbWasmABI, "activateProgram")
@@ -243,7 +254,7 @@ func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)
 
 	// Ensure the revert also reverted keccak's activation
 	checkReverts()
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 
 	// Activate keccak program A, then call into B, which should succeed due to being the same codehash
 	args = argsForMulticall(vm.CALL, types.ArbWasmAddress, oneEth, pack(activateProgram(keccakA)))
@@ -251,7 +262,7 @@ func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)
 
 	tx = l2info.PrepareTxTo("Owner", &multiAddr, 1e9, oneEth, args)
 	ensure(tx, l2client.SendTransaction(ctx, tx))
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 2)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 2)
 
 	validateBlocks(t, 7, jit, builder)
 }
@@ -2083,7 +2094,7 @@ func TestWasmStoreRebuilding(t *testing.T) {
 	storeMap, err := createMapFromDb(wasmDb)
 	Require(t, err)
 
-	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.WasmTargets(), 1)
 	// close nodeB
 	cleanupB()
 
@@ -2140,7 +2151,7 @@ func TestWasmStoreRebuilding(t *testing.T) {
 		}
 	}
 
-	checkWasmStoreContent(t, wasmDbAfterRebuild, builder.execConfig.StylusTarget.ExtraArchs, 1)
+	checkWasmStoreContent(t, wasmDbAfterRebuild, builder.execConfig.StylusTarget.WasmTargets(), 1)
 	cleanupB()
 }
 
@@ -2167,25 +2178,43 @@ func readModuleHashes(t *testing.T, wasmDb ethdb.KeyValueStore) []common.Hash {
 	return modules
 }
 
-func checkWasmStoreContent(t *testing.T, wasmDb ethdb.KeyValueStore, targets []string, numModules int) {
+func checkWasmStoreContent(t *testing.T, wasmDb ethdb.KeyValueStore, expectedTargets []ethdb.WasmTarget, numModules int) {
+	t.Helper()
 	modules := readModuleHashes(t, wasmDb)
 	if len(modules) != numModules {
 		t.Fatalf("Unexpected number of module hashes found in wasm store, want: %d, have: %d", numModules, len(modules))
 	}
+	readAsm := func(module common.Hash, target string) []byte {
+		wasmTarget := ethdb.WasmTarget(target)
+		if !rawdb.IsSupportedWasmTarget(wasmTarget) {
+			t.Fatalf("internal test error - unsupported target passed to checkWasmStoreContent: %v", target)
+		}
+		return func() []byte {
+			t.Helper()
+			defer func() {
+				if r := recover(); r != nil {
+					t.Fatalf("Failed to read activated asm for target: %v, module: %v", target, module)
+				}
+			}()
+			return rawdb.ReadActivatedAsm(wasmDb, wasmTarget, module)
+		}()
+	}
 	for _, module := range modules {
-		for _, target := range targets {
-			wasmTarget := ethdb.WasmTarget(target)
-			if !rawdb.IsSupportedWasmTarget(wasmTarget) {
-				t.Fatalf("internal test error - unsupported target passed to checkWasmStoreContent: %v", target)
+		for _, target := range allWasmTargets {
+			var expected bool
+			for _, expectedTarget := range expectedTargets {
+				if ethdb.WasmTarget(target) == expectedTarget {
+					expected = true
+					break
+				}
+			}
+			asm := readAsm(module, target)
+			if expected && len(asm) == 0 {
+				t.Fatalf("Missing asm for target: %v, module: %v", target, module)
+			}
+			if !expected && len(asm) > 0 {
+				t.Fatalf("Found asm for target: %v, module: %v, expected targets: %v", target, module, expectedTargets)
 			}
-			func() {
-				defer func() {
-					if r := recover(); r != nil {
-						t.Fatalf("Failed to read activated asm for target: %v, module: %v", target, module)
-					}
-				}()
-				_ = rawdb.ReadActivatedAsm(wasmDb, wasmTarget, module)
-			}()
 		}
 	}
 }
diff --git a/system_tests/staker_test.go b/system_tests/staker_test.go
index 69645d8878..55c13d664d 100644
--- a/system_tests/staker_test.go
+++ b/system_tests/staker_test.go
@@ -504,7 +504,7 @@ func TestGetValidatorWalletContractWithDataposterOnlyUsedToCreateValidatorWallet
 		parentChainID,
 	)
 	if err != nil {
-		log.Crit("error creating data poster to create validator wallet contract", "err", err)
+		Fatal(t, "error creating data poster to create validator wallet contract", "err", err)
 	}
 	getExtraGas := func() uint64 { return builder.nodeConfig.Staker.ExtraGas }