@@ -151,7 +151,7 @@ serde = "1.0.217"
 serde_derive = "1.0"
 serde_json = "1.0"
 sha3 = "0.10.8"
-solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "731fa50" }
+solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "5afcedc" }
 solana-account-decoder = { version = "2.2" }
 solana-accounts-db = { version = "2.2" }
 solana-account-decoder-client-types = { version = "2.2" }
@@ -220,13 +220,13 @@ vergen = "8.3.1"
 
 [workspace.dependencies.solana-svm]
 git = "https://github.com/magicblock-labs/magicblock-svm.git"
-rev = "11bbaf2"
+rev = "e480fa2"
 features = ["dev-context-only-utils"]
 
 [patch.crates-io]
 # some solana dependencies have solana-storage-proto as dependency
 # we need to patch them with our version, because they use protobuf-src v1.1.0
 # and we use protobuf-src v2.1.1. Otherwise compilation fails
-solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "731fa50" }
+solana-account = { git = "https://github.com/magicblock-labs/solana-account.git", rev = "5afcedc" }
 solana-storage-proto = { path = "./storage-proto" }
-solana-svm = { git = "https://github.com/magicblock-labs/magicblock-svm.git", rev = "11bbaf2" }
+solana-svm = { git = "https://github.com/magicblock-labs/magicblock-svm.git", rev = "e480fa2" }
@@ -20,6 +20,7 @@ tokio = { workspace = true }
 tokio-util = { workspace = true }
 
 # containers
+arc-swap = { workspace = true }
 scc = { workspace = true }
 
 # sync
 
@@ -83,16 +83,20 @@ impl EventProcessor {
     }
 
     /// The main event processing loop for a single worker instance.
-    ///
-    /// This function listens on all event channels concurrently and processes messages
-    /// as they arrive. The `tokio::select!` macro is biased to prioritize account
-    /// processing, as it is typically the most frequent and time-sensitive event.
     async fn run(self, id: usize, cancel: CancellationToken) {
         info!("event processor {id} is running");
         loop {
             tokio::select! {
                 biased;
 
+                // Process a new block.
+                Ok(latest) = self.block_update_rx.recv_async() => {
+                    // Notify subscribers waiting on slot updates.
+                    self.subscriptions.send_slot(latest.meta.slot);
+                    // Update the global blocks cache with the latest block.
+                    self.blocks.set_latest(latest);
+                }
+
                 // Process a new account state update.
                 Ok(state) = self.account_update_rx.recv_async() => {
                     // Notify subscribers for this specific account.
@@ -121,14 +125,6 @@ impl EventProcessor {
                     self.transactions.push(status.signature, Some(result));
                 }
 
-                // Process a new block.
-                Ok(latest) = self.block_update_rx.recv_async() => {
-                    // Notify subscribers waiting on slot updates.
-                    self.subscriptions.send_slot(latest.meta.slot);
-                    // Update the global blocks cache with the latest block.
-                    self.blocks.set_latest(latest);
-                }
-
                 // Listen for the cancellation signal to gracefully shut down.
                 _ = cancel.cancelled() => {
                     break;
 
@@ -176,13 +176,14 @@ impl HttpDispatcher {
     fn handle_cors_preflight() -> Result<Response<JsonBody>, Infallible> {
         use hyper::header::{
             ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS,
-            ACCESS_CONTROL_ALLOW_ORIGIN,
+            ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_MAX_AGE,
         };
 
         let response = Response::builder()
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-            .header(ACCESS_CONTROL_ALLOW_METHODS, "POST, OPTIONS")
+            .header(ACCESS_CONTROL_ALLOW_METHODS, "POST, OPTIONS, GET")
             .header(ACCESS_CONTROL_ALLOW_HEADERS, "*")
+            .header(ACCESS_CONTROL_MAX_AGE, "86400")
             .body(JsonBody::from(""))
             // SAFETY: This is safe with static, valid headers
             .expect("Building CORS response failed");
 
@@ -1,10 +1,10 @@
-use std::{ops::Deref, time::Duration};
+use std::{ops::Deref, sync::Arc, time::Duration};
 
+use arc_swap::ArcSwapAny;
 use magicblock_core::{
     link::blocks::{BlockHash, BlockMeta, BlockUpdate},
     Slot,
 };
-use magicblock_ledger::LatestBlock;
 use solana_rpc_client_api::response::RpcBlockhash;
 
 use super::ExpiringCache;
@@ -23,12 +23,20 @@ pub(crate) struct BlocksCache {
     /// The number of slots for which a blockhash is considered valid.
     /// This is calculated based on the host ER's block time relative to Solana's.
     block_validity: u64,
-    /// The most recent block update received, protected by a `RwLock` for concurrent access.
-    latest: LatestBlock,
+    /// Latest observed block (updated whenever the ledger transitions to new slot)
+    latest: ArcSwapAny<Arc<LastCachedBlock>>,
     /// An underlying time-based cache for storing `BlockHash` to `BlockMeta` mappings.
     cache: ExpiringCache<BlockHash, BlockMeta>,
 }
 
+/// Last produced block that has been put into cache. We need to keep this separately,
+/// as there's no way to access the cache efficiently to find the latest inserted entry
+#[derive(Default, Debug, Clone, Copy)]
+pub(crate) struct LastCachedBlock {
+    pub(crate) blockhash: BlockHash,
+    pub(crate) slot: Slot,
+}
+
 impl Deref for BlocksCache {
     type Target = ExpiringCache<BlockHash, BlockMeta>;
     fn deref(&self) -> &Self::Target {
@@ -44,7 +52,7 @@ impl BlocksCache {
     ///
     /// # Panics
     /// Panics if `blocktime` is zero.
-    pub(crate) fn new(blocktime: u64, latest: LatestBlock) -> Self {
+    pub(crate) fn new(blocktime: u64, latest: LastCachedBlock) -> Self {
         const BLOCK_CACHE_TTL: Duration = Duration::from_secs(60);
         assert!(blocktime != 0, "blocktime cannot be zero");
 
@@ -54,16 +62,23 @@ impl BlocksCache {
         let block_validity = blocktime_ratio * MAX_VALID_BLOCKHASH_SLOTS;
         let cache = ExpiringCache::new(BLOCK_CACHE_TTL);
         Self {
-            latest,
+            latest: ArcSwapAny::new(latest.into()),
             block_validity: block_validity as u64,
             cache,
         }
     }
 
     /// Updates the latest block information in the cache.
     pub(crate) fn set_latest(&self, latest: BlockUpdate) {
-        // The `push` method adds the blockhash to the underlying expiring cache.
+        let last = LastCachedBlock {
+            blockhash: latest.hash,
+            slot: latest.meta.slot,
+        };
+
+        // Register the block in the expiring cache
         self.cache.push(latest.hash, latest.meta);
+        // And mark it as latest observed
+        self.latest.swap(last.into());
     }
 
     /// Retrieves information about the latest block, including its calculated validity period.
@@ -83,6 +98,7 @@ impl BlocksCache {
 }
 
 /// A data structure containing essential details about a blockhash for RPC responses.
+#[derive(Default)]
 pub(crate) struct BlockHashInfo {
     /// The blockhash.
     pub(crate) hash: BlockHash,
 
@@ -1,6 +1,6 @@
 use std::{sync::Arc, time::Duration};
 
-use blocks::BlocksCache;
+use blocks::{BlocksCache, LastCachedBlock};
 use cache::ExpiringCache;
 use magicblock_account_cloner::ChainlinkCloner;
 use magicblock_accounts_db::AccountsDb;
@@ -81,7 +81,11 @@ impl SharedState {
         blocktime: u64,
     ) -> Self {
         const TRANSACTIONS_CACHE_TTL: Duration = Duration::from_secs(75);
-        let latest = ledger.latest_block().clone();
+        let block = ledger.latest_block().load();
+        let latest = LastCachedBlock {
+            blockhash: block.blockhash,
+            slot: block.slot,
+        };
         Self {
             context,
             accountsdb,
 
@@ -27,6 +27,8 @@ use crate::{
     EventProcessor,
 };
 
+const LAMPORTS_PER_SOL: u64 = 1_000_000_000;
+
 /// A test helper to create a unique WebSocket connection channel pair.
 fn ws_channel() -> (WsConnectionChannel, Receiver<Bytes>) {
     static CHAN_ID: AtomicU32 = AtomicU32::new(0);
@@ -100,7 +102,9 @@ mod event_processor {
     #[tokio::test]
     async fn test_account_update() {
         let (state, env) = setup();
-        let acc = env.create_account_with_config(1, 1, guinea::ID).pubkey();
+        let acc = env
+            .create_account_with_config(LAMPORTS_PER_SOL, 1, guinea::ID)
+            .pubkey();
         let (tx, mut rx) = ws_channel();
 
         // Subscribe to both the specific account and the program that owns it.
@@ -140,7 +144,9 @@ mod event_processor {
     #[tokio::test]
     async fn test_transaction_update() {
         let (state, env) = setup();
-        let acc = env.create_account_with_config(1, 42, guinea::ID).pubkey();
+        let acc = env
+            .create_account_with_config(LAMPORTS_PER_SOL, 42, guinea::ID)
+            .pubkey();
         let (tx, mut rx) = ws_channel();
 
         let ix = Instruction::new_with_bincode(
@@ -201,7 +207,9 @@ mod event_processor {
         let (state, env) = setup();
 
         // Test multiple subscriptions to the same ACCOUNT.
-        let acc1 = env.create_account_with_config(1, 1, guinea::ID).pubkey();
+        let acc1 = env
+            .create_account_with_config(LAMPORTS_PER_SOL, 1, guinea::ID)
+            .pubkey();
         let (acc_tx1, mut acc_rx1) = ws_channel();
         let (acc_tx2, mut acc_rx2) = ws_channel();
 
@@ -227,7 +235,9 @@ mod event_processor {
         assert_receives_update(&mut acc_rx2, "second account subscriber").await;
 
         // Test multiple subscriptions to the same PROGRAM.
-        let acc2 = env.create_account_with_config(1, 1, guinea::ID).pubkey();
+        let acc2 = env
+            .create_account_with_config(LAMPORTS_PER_SOL, 1, guinea::ID)
+            .pubkey();
         let (prog_tx1, mut prog_rx1) = ws_channel();
         let (prog_tx2, mut prog_rx2) = ws_channel();
         let prog_encoder = ProgramAccountEncoder {
 
@@ -157,7 +157,6 @@ impl MagicValidator {
         let GenesisConfigInfo {
             genesis_config,
             validator_pubkey,
-            ..
         } = create_genesis_config_with_leader(
             u64::MAX,
             &validator_pubkey,
@@ -274,7 +273,7 @@ impl MagicValidator {
             });
 
         validator::init_validator_authority(identity_keypair);
-
+        let base_fee = config.validator.base_fees.unwrap_or_default();
         let txn_scheduler_state = TransactionSchedulerState {
             accountsdb: accountsdb.clone(),
             ledger: ledger.clone(),
@@ -303,7 +302,7 @@ impl MagicValidator {
         let node_context = NodeContext {
             identity: validator_pubkey,
             faucet,
-            base_fee: config.validator.base_fees.unwrap_or_default(),
+            base_fee,
             featureset: txn_scheduler_state.environment.feature_set.clone(),
         };
         let transaction_scheduler =
 
@@ -244,43 +244,37 @@ Kept: {} delegated, {} blacklisted",
             .copied()
             .collect::<Vec<_>>();
         let feepayer = tx.message().fee_payer();
-        // In the case of transactions we need to clone the feepayer account
-        let clone_escrow = {
-            // If the fee payer account is in the bank we only clone the balance
-            // escrow account if the fee payer is not delegated
-            // If it is not in the bank we include it just in case, it is fine
-            // if it doesn't exist and once we cloned the feepayer account itself
-            // and it turns out to be delegated, then we will avoid cloning the
-            // escrow account next time
-            self.accounts_bank
-                .get_account(feepayer)
-                .is_none_or(|a| !a.delegated())
-        };
 
-        // Always allow the fee payer to be treated as empty-if-not-found so that
-        // transactions can still be processed in gasless mode
-        let mut mark_empty_if_not_found = vec![*feepayer];
+        // Determine if we need to clone the escrow account for the feepayer
+        let clone_escrow = self
+            .accounts_bank
+            .get_account(feepayer)
+            .is_none_or(|a| !a.delegated());
 
+        // If cloning escrow, add the balance PDA
         if clone_escrow {
             let balance_pda = ephemeral_balance_pda_from_payer(feepayer, 0);
             trace!("Adding balance PDA {balance_pda} for feepayer {feepayer}");
             pubkeys.push(balance_pda);
-            mark_empty_if_not_found.push(balance_pda);
         }
-        let mark_empty_if_not_found = (!mark_empty_if_not_found.is_empty())
-            .then(|| &mark_empty_if_not_found[..]);
+
+        // Mark *all* pubkeys as empty-if-not-found
+        let mark_empty_if_not_found = Some(pubkeys.as_slice());
+
+        // Ensure accounts
         let res = self
             .ensure_accounts(&pubkeys, mark_empty_if_not_found)
             .await?;
 
-        // Best-effort auto airdrop for fee payer if configured and still empty locally
+        // Best-effort auto airdrop for fee payer if configured
         if self.auto_airdrop_lamports > 0 {
             if let Some(fetch_cloner) = self.fetch_cloner() {
                 let lamports = self
                     .accounts_bank
                     .get_account(feepayer)
                     .map(|a| a.lamports())
                     .unwrap_or(0);
+
                 if lamports == 0 {
                     if let Err(err) = fetch_cloner
                         .airdrop_account_if_empty(