apply: admit BatchTransfers blocks, warm the block's accounts in one multi_get

The batch run proved the whole signed path — 892 transfers/s included on-chain —
and then wedged the network: the block-level internal-type guard still listed
BatchTransfers among the genesis-only/deprecated variants and hard-rejected any
block carrying one. The producer admitted batches through the (opened) mempool
gates and included them; every validator rejected the block. Admission, gossip,
value-class, validate and apply had all been opened — this fifth site had not.
BatchTransfers leaves the forbidden list; CreateAccount, BatchRewardClaims and
BatchNodeActivations stay rejected. Every remaining reference to the type across
the codebase is now accounted for.

Block-apply account warm-up goes through ONE RocksDB multi_get instead of one
point read per address. The block already collects and dedupes every affected
address (batch recipients included); only the miss path changes — resident
accounts keep the exact hit/touch semantics. Measured 240-tx blocks spent
543-851 ms in apply, consistent with hundreds of sequential cold point reads on
VPS disks; AccountStore grows load_accounts_batch with a sequential default so
non-RocksDB stores are untouched.

Ladder on the previous image, for the record: 250 TPS 13433/13433 finalized and
500 TPS 22913/22913 finalized (382 sustained), 100% success both — the loads
that previously killed the network.

Tests: 420 integration + 176 state, zero warnings.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: AIQnetLab

core/qnet-state/src/state.rs

@@ -1700,6 +1700,14 @@ pub trait AccountStore: Send + Sync {
     /// the canonical "account not found" path).
     fn load_account(&self, address: &str) -> Option<Account>;
 
+    /// Batched best-effort read; result order matches `addresses`. Default is N
+    /// single reads so simple stores stay correct; the RocksDB store overrides
+    /// this with one multi_get — the block-apply warm was N sequential point
+    /// reads, the dominant cost of applying a loaded block.
+    fn load_accounts_batch(&self, addresses: &[String]) -> Vec<Option<Account>> {
+        addresses.iter().map(|a| self.load_account(a)).collect()
+    }
+
     /// Durable batch write of accounts. Called by the eviction sweep BEFORE dropping entries from the
     /// cache; returns true IFF the write durably succeeded. The evictor removes ONLY a successfully-
     /// persisted batch, so a failed persist (I/O error, or no store) keeps the accounts resident —
@@ -1921,11 +1929,37 @@ impl StateManager {
     /// to ensure every sender / receiver / contract address the block
     /// touches is resident before the apply mutates state. Returns the
     /// count of addresses that ended up resident (cache hit + disk hit).
+    /// Misses are loaded in ONE multi_get instead of per-address point reads.
     pub fn warm_accounts(&self, addresses: &[String]) -> usize {
         let mut hit = 0usize;
+        let mut misses: Vec<String> = Vec::new();
         for addr in addresses {
-            if self.warm_account(addr) {
+            if self.accounts.contains_key(addr) {
+                self.cache_hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                self.touch_access(addr);
                 hit = hit.saturating_add(1);
+            } else {
+                self.cache_misses.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                misses.push(addr.clone());
+            }
+        }
+        if misses.is_empty() { return hit; }
+        let store_guard = self.disk_store.read();
+        if let Some(ref store) = *store_guard {
+            for (addr, loaded) in misses.iter().zip(store.load_accounts_batch(&misses)) {
+                match loaded {
+                    Some(account) => {
+                        self.disk_load_hits.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                        // Race-tolerant: keep an entry inserted concurrently — identical
+                        // bytes, load_accounts_batch is deterministic on the same store.
+                        self.accounts.entry(addr.clone()).or_insert(account);
+                        self.touch_access(addr);
+                        hit = hit.saturating_add(1);
+                    }
+                    None => {
+                        self.disk_load_misses.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+                    }
+                }
             }
         }
         hit

development/qnet-integration/src/block_pipeline.rs

@@ -2644,15 +2644,15 @@ impl BlockPipeline {
             // Internal-only TX type guard: post-genesis, HARD REJECT the whole
             // block (+ peer reputation penalty) if it carries a genesis-only or
             // deprecated variant (CreateAccount / BatchRewardClaims /
-            // BatchNodeActivations / BatchTransfers) — a Byzantine producer
-            // could embed one bypassing mempool admission. O(tx_count).
+            // BatchNodeActivations) — a Byzantine producer could embed one
+            // bypassing mempool admission. BatchTransfers is a live signed value
+            // class (bounds + ML-DSA gate run at verify/apply). O(tx_count).
             if mb.height > 0 {
                 for tx in &decoded.microblock.transactions {
                     let forbidden = matches!(tx.tx_type,
                         qnet_state::TransactionType::CreateAccount { .. } |
                         qnet_state::TransactionType::BatchRewardClaims { .. } |
-                        qnet_state::TransactionType::BatchNodeActivations { .. } |
-                        qnet_state::TransactionType::BatchTransfers { .. }
+                        qnet_state::TransactionType::BatchNodeActivations { .. }
                     );
                     if forbidden {
                         if is_warn() {

development/qnet-integration/src/node/transactions.rs

@@ -1588,7 +1588,7 @@ impl BlockchainNode {
         //                            Any post-genesis CreateAccount is an attack.
         //   * BatchRewardClaims   — DEPRECATED enum variant, never instantiated.
         //   * BatchNodeActivations — DEPRECATED enum variant, never instantiated.
-        //   * BatchTransfers      — UNUSED handler-only enum variant.
+        //   * BatchTransfers      — LIVE signed value class; bounds checked below.
         //
         // SCALABILITY: O(1) match per gossip TX. Identical cost at 5 or 5000
         // validators — no cross-node coordination, purely local check.

development/qnet-integration/src/storage/mod.rs

@@ -1800,6 +1800,11 @@ impl qnet_state::AccountStore for Storage {
         }
     }
 
+    fn load_accounts_batch(&self, addresses: &[String]) -> Vec<Option<qnet_state::Account>> {
+        // One RocksDB multi_get over the accounts CF (reward_store.rs).
+        Storage::load_accounts_batch(self, addresses)
+    }
+
     fn persist_accounts(&self, accounts: &[(String, qnet_state::Account)]) -> bool {
         match self.persistent.persist_accounts_sync(accounts) {
             Ok(_) => true,