fix: remove check GetAccount keys check in store

crates/store/src/inner_forest/mod.rs

@@ -216,9 +216,6 @@ impl InnerForest {
     ///
     /// Returns `None` if no storage root is tracked for this account/slot/block combination.
     /// Returns a `MerkleError` if the forest doesn't contain sufficient data for the proofs.
-    ///
-    /// If the number of requested keys exceeds [`AccountStorageMapDetails::MAX_SMT_PROOF_ENTRIES`],
-    /// returns `LimitExceeded`.
     pub(crate) fn open_storage_map(
         &self,
         account_id: AccountId,
@@ -228,13 +225,6 @@ impl InnerForest {
     ) -> Option<Result<AccountStorageMapDetails, MerkleError>> {
         let root = self.get_storage_map_root(account_id, &slot_name, block_num)?;
 
-        if raw_keys.len() > AccountStorageMapDetails::MAX_SMT_PROOF_ENTRIES {
-            return Some(Ok(AccountStorageMapDetails {
-                slot_name,
-                entries: StorageMapEntries::LimitExceeded,
-            }));
-        }
-
         // Collect SMT proofs for each key
         let proofs = Result::from_iter(raw_keys.iter().map(|raw_key| {
             let key = StorageMap::hash_key(*raw_key);

crates/store/src/inner_forest/tests.rs

@@ -428,37 +428,3 @@ fn test_storage_map_incremental_updates() {
     assert_ne!(root_2, root_3);
     assert_ne!(root_1, root_3);
 }
-
-#[test]
-fn test_open_storage_map_returns_limit_exceeded_for_too_many_keys() {
-    use std::collections::BTreeMap;
-
-    use assert_matches::assert_matches;
-    use miden_protocol::account::delta::{StorageMapDelta, StorageSlotDelta};
-
-    let mut forest = InnerForest::new();
-    let account_id = dummy_account();
-    let slot_name = StorageSlotName::mock(3);
-    let block_num = BlockNumber::GENESIS.child();
-
-    // Create a storage map with entries
-    let num_entries = AccountStorageMapDetails::MAX_SMT_PROOF_ENTRIES + 5;
-    let mut map_delta = StorageMapDelta::default();
-    for i in 0..num_entries as u32 {
-        let key = Word::from([i, 0, 0, 0]);
-        let value = Word::from([0, 0, 0, i]);
-        map_delta.insert(key, value);
-    }
-    let raw = BTreeMap::from_iter([(slot_name.clone(), StorageSlotDelta::Map(map_delta))]);
-    let storage_delta = AccountStorageDelta::from_raw(raw);
-    let delta = dummy_partial_delta(account_id, AccountVaultDelta::default(), storage_delta);
-    forest.update_account(block_num, &delta).unwrap();
-
-    // Request proofs for more than MAX_SMT_PROOF_ENTRIES keys.
-    // Should return LimitExceeded.
-    let keys: Vec<Word> = (0..num_entries as u32).map(|i| Word::from([i, 0, 0, 0])).collect();
-    let result = forest.open_storage_map(account_id, slot_name.clone(), block_num, &keys);
-
-    let details = result.expect("Should return Some").expect("Should not error");
-    assert_matches!(details.entries, StorageMapEntries::LimitExceeded);
-}

crates/store/src/state/mod.rs

@@ -1087,25 +1087,6 @@ impl State {
             None => AccountVaultDetails::empty(),
         };
 
-        // Check total keys limit upfront before expensive open operations
-        let total_keys: usize = storage_requests
-            .iter()
-            .filter_map(|req| match &req.slot_data {
-                SlotData::MapKeys(keys) => Some(keys.len()),
-                SlotData::All => None,
-            })
-            .sum();
-
-        if total_keys > AccountStorageMapDetails::MAX_SMT_PROOF_ENTRIES {
-            return Ok(AccountDetails::with_storage_limits_exceeded(
-                account_header,
-                account_code,
-                vault_details,
-                storage_header,
-                storage_requests.into_iter().map(|req| req.slot_name),
-            ));
-        }
-
         let mut storage_map_details =
             Vec::<AccountStorageMapDetails>::with_capacity(storage_requests.len());