From 84cf9c73ed8e587b084b2494ec7fa422be498062 Mon Sep 17 00:00:00 2001
From: garyschulte <garyschulte@gmail.com>
Date: Fri, 25 Oct 2024 10:31:04 -0700
Subject: [PATCH] merge rebase squash commit for preimage store

Signed-off-by: garyschulte <garyschulte@gmail.com>
---
 CHANGELOG.md                                  |   5 +
 .../org/hyperledger/besu/cli/BesuCommand.java |   3 +
 .../options/storage/DataStorageOptions.java   |  13 ++
 .../storage/DiffBasedSubStorageOptions.java   |  16 +-
 .../besu/services/BesuConfigurationImpl.java  |   7 +-
 .../stable/DataStorageOptionsTest.java        |  14 --
 .../src/test/resources/everything_config.toml |   3 +-
 build.gradle                                  |   2 +-
 .../keyvalue/KeyValueSegmentIdentifier.java   |   3 +-
 .../KeyValueStorageProviderBuilder.java       |  15 +-
 .../WorldStatePreimageKeyValueStorage.java    |  10 +
 .../bonsai/storage/BonsaiPreImageProxy.java   |  67 ------
 .../BonsaiWorldStateKeyValueStorage.java      |   7 -
 .../storage/CachingPreImageStorage.java       | 195 ++++++++++++++++++
 .../bonsai/worldview/BonsaiWorldState.java    |  15 +-
 .../DiffBasedWorldStateKeyValueStorage.java   |  68 ++++++
 .../common/worldview/DiffBasedWorldState.java |  17 +-
 .../common/worldview/DiffBasedWorldView.java  |   4 +
 .../DiffBasedWorldStateUpdateAccumulator.java |  31 ++-
 .../worldstate/DataStorageConfiguration.java  |  12 +-
 .../worldstate/WorldStatePreimageStorage.java |   1 +
 .../bonsai/AbstractIsolationTests.java        |   7 +-
 .../BonsaiReferenceTestUpdateAccumulator.java |  22 +-
 .../BonsaiReferenceTestWorldState.java        |  34 +--
 .../BonsaiReferenceTestWorldStateStorage.java |  87 --------
 .../evm/worldstate/AbstractWorldUpdater.java  |   4 +-
 plugin-api/build.gradle                       |   2 +-
 .../storage/DataStorageConfiguration.java     |  11 +-
 .../RocksDBKeyValueStorageFactory.java        |   4 +-
 .../BaseVersionedStorageFormat.java           |   2 +-
 .../PrivacyVersionedStorageFormat.java        |   2 +-
 .../rocksdb/NearestKeyValueStorageTest.java   |   2 +-
 ...ksDBKeyValuePrivacyStorageFactoryTest.java |   2 +-
 .../RocksDBKeyValueStorageFactoryTest.java    |   2 +-
 34 files changed, 406 insertions(+), 283 deletions(-)
 delete mode 100644 ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiPreImageProxy.java
 create mode 100644 ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/CachingPreImageStorage.java
 delete mode 100644 ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldStateStorage.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f862ed866fe..4dccf056f37 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,11 @@
 - Added isLabelsObserved to LabelledGauge in plugin-api. Default implementation returns false.
 
 ### Breaking Changes
+- Removed deprecated experimental feature names 
+  - `--Xsnapsync-synchronizer-flat-db-healing-enabled` in favor of `--Xbonsai-full-flat-db-enabled` 
+  - `--Xbonsai-limit-trie-logs-enabled` and `--Xbonsai-trie-log-pruning-enabled` in favor of `--bonsai-limit-trie-logs-enabled`
+  - `--Xbonsai-trie-logs-pruning-window-size` in favor of `--bonsai-trie-logs-pruning-window-size` 
+
 
 ### Upcoming Breaking Changes
 
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java b/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
index 886e3d68383..aa75c25c01b 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
@@ -2624,6 +2624,9 @@ public void setIgnorableStorageSegments() {
     if (!unstableChainPruningOptions.getChainDataPruningEnabled()) {
       rocksDBPlugin.addIgnorableSegmentIdentifier(KeyValueSegmentIdentifier.CHAIN_PRUNER_STATE);
     }
+    if (!dataStorageOptions.toDomainObject().getHashPreImageStorageEnabled()) {
+      rocksDBPlugin.addIgnorableSegmentIdentifier(KeyValueSegmentIdentifier.HASH_PREIMAGE_STORE);
+    }
   }
 
   private void validatePostMergeCheckpointBlockRequirements() {
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DataStorageOptions.java b/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DataStorageOptions.java
index fbc57f50def..e7cb1372377 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DataStorageOptions.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DataStorageOptions.java
@@ -14,6 +14,7 @@
  */
 package org.hyperledger.besu.cli.options.storage;
 
+import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.DEFAULT_HASH_PREIMAGE_STORAGE_ENABLED;
 import static org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration.DEFAULT_RECEIPT_COMPACTION_ENABLED;
 
 import org.hyperledger.besu.cli.options.CLIOptions;
@@ -35,6 +36,9 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
 
   private static final String DATA_STORAGE_FORMAT = "--data-storage-format";
 
+  /** Feature to store hash preimages as part of worldstate */
+  public static final String HASH_STORE_PREIMAGE_ENABLED = "--hash-preimage-storage-enabled";
+
   // Use Bonsai DB
   @Option(
       names = {DATA_STORAGE_FORMAT},
@@ -49,6 +53,13 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
       fallbackValue = "true")
   private Boolean receiptCompactionEnabled = DEFAULT_RECEIPT_COMPACTION_ENABLED;
 
+  @CommandLine.Option(
+      names = {HASH_STORE_PREIMAGE_ENABLED},
+      description =
+          "Format to store trie data in.  Either FOREST or BONSAI (default: ${DEFAULT-VALUE}).",
+      arity = "1")
+  private Boolean hashStorePreimagesEnabled = DEFAULT_HASH_PREIMAGE_STORAGE_ENABLED;
+
   /**
    * Options specific to diff-based storage modes. Holds the necessary parameters to configure
    * diff-based storage, such as the Bonsai mode or Verkle in the future.
@@ -88,6 +99,7 @@ public static DataStorageOptions fromConfig(final DataStorageConfiguration domai
     final DataStorageOptions dataStorageOptions = DataStorageOptions.create();
     dataStorageOptions.dataStorageFormat = domainObject.getDataStorageFormat();
     dataStorageOptions.receiptCompactionEnabled = domainObject.getReceiptCompactionEnabled();
+    dataStorageOptions.hashStorePreimagesEnabled = domainObject.getHashPreImageStorageEnabled();
     dataStorageOptions.diffBasedSubStorageOptions =
         DiffBasedSubStorageOptions.fromConfig(domainObject.getDiffBasedSubStorageConfiguration());
     return dataStorageOptions;
@@ -99,6 +111,7 @@ public DataStorageConfiguration toDomainObject() {
         ImmutableDataStorageConfiguration.builder()
             .dataStorageFormat(dataStorageFormat)
             .receiptCompactionEnabled(receiptCompactionEnabled)
+            .hashPreImageStorageEnabled(hashStorePreimagesEnabled)
             .diffBasedSubStorageConfiguration(diffBasedSubStorageOptions.toDomainObject());
     return builder.build();
   }
diff --git a/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java b/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java
index c95a7668272..5717786b09b 100644
--- a/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java
+++ b/besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java
@@ -55,26 +55,16 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
   public static final String TRIE_LOG_PRUNING_WINDOW_SIZE =
       "--bonsai-trie-logs-pruning-window-size";
 
-  // TODO --Xbonsai-limit-trie-logs-enabled and --Xbonsai-trie-log-pruning-enabled are deprecated,
-  // remove in a future release
   @SuppressWarnings("ExperimentalCliOptionMustBeCorrectlyDisplayed")
   @Option(
-      names = {
-        LIMIT_TRIE_LOGS_ENABLED,
-        "--Xbonsai-limit-trie-logs-enabled", // deprecated
-        "--Xbonsai-trie-log-pruning-enabled" // deprecated
-      },
+      names = {LIMIT_TRIE_LOGS_ENABLED},
       fallbackValue = "true",
       description = "Limit the number of trie logs that are retained. (default: ${DEFAULT-VALUE})")
   private Boolean limitTrieLogsEnabled = DEFAULT_LIMIT_TRIE_LOGS_ENABLED;
 
-  // TODO --Xbonsai-trie-logs-pruning-window-size is deprecated, remove in a future release
   @SuppressWarnings("ExperimentalCliOptionMustBeCorrectlyDisplayed")
   @Option(
-      names = {
-        TRIE_LOG_PRUNING_WINDOW_SIZE,
-        "--Xbonsai-trie-logs-pruning-window-size" // deprecated
-      },
+      names = {TRIE_LOG_PRUNING_WINDOW_SIZE},
       description =
           "The max number of blocks to load and prune trie logs for at startup. (default: ${DEFAULT-VALUE})")
   private Integer trieLogPruningWindowSize = DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
@@ -88,13 +78,11 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
   /** The unstable options for data storage. */
   public static class Unstable {
 
-    // TODO: --Xsnapsync-synchronizer-flat-db-healing-enabled is deprecated, remove it in a future
     // release
     @Option(
         hidden = true,
         names = {
           "--Xbonsai-full-flat-db-enabled",
-          "--Xsnapsync-synchronizer-flat-db-healing-enabled"
         },
         arity = "1",
         description = "Enables bonsai full flat database strategy. (default: ${DEFAULT-VALUE})")
diff --git a/besu/src/main/java/org/hyperledger/besu/services/BesuConfigurationImpl.java b/besu/src/main/java/org/hyperledger/besu/services/BesuConfigurationImpl.java
index 0adbda23b74..287e5eba53f 100644
--- a/besu/src/main/java/org/hyperledger/besu/services/BesuConfigurationImpl.java
+++ b/besu/src/main/java/org/hyperledger/besu/services/BesuConfigurationImpl.java
@@ -133,7 +133,7 @@ public DataStoreConfigurationImpl(final DataStorageConfiguration dataStorageConf
     }
 
     @Override
-    public DataStorageFormat getDatabaseFormat() {
+    public DataStorageFormat getDataStorageFormat() {
       return dataStorageConfiguration.getDataStorageFormat();
     }
 
@@ -141,5 +141,10 @@ public DataStorageFormat getDatabaseFormat() {
     public boolean getReceiptCompactionEnabled() {
       return dataStorageConfiguration.getReceiptCompactionEnabled();
     }
+
+    @Override
+    public boolean getHashPreImageStorageEnabled() {
+      return dataStorageConfiguration.getHashPreImageStorageEnabled();
+    }
   }
 }
diff --git a/besu/src/test/java/org/hyperledger/besu/cli/options/stable/DataStorageOptionsTest.java b/besu/src/test/java/org/hyperledger/besu/cli/options/stable/DataStorageOptionsTest.java
index b9dc4fa9270..539ef7d1bc5 100644
--- a/besu/src/test/java/org/hyperledger/besu/cli/options/stable/DataStorageOptionsTest.java
+++ b/besu/src/test/java/org/hyperledger/besu/cli/options/stable/DataStorageOptionsTest.java
@@ -43,20 +43,6 @@ public void bonsaiTrieLogPruningLimitOption() {
         "600");
   }
 
-  @Test
-  public void bonsaiTrieLogPruningLimitLegacyOption() {
-    internalTestSuccess(
-        dataStorageConfiguration ->
-            assertThat(
-                    dataStorageConfiguration
-                        .getDiffBasedSubStorageConfiguration()
-                        .getTrieLogPruningWindowSize())
-                .isEqualTo(600),
-        "--Xbonsai-limit-trie-logs-enabled",
-        "--Xbonsai-trie-logs-pruning-window-size",
-        "600");
-  }
-
   @Test
   public void bonsaiTrieLogsEnabled_explicitlySetToFalse() {
     internalTestSuccess(
diff --git a/besu/src/test/resources/everything_config.toml b/besu/src/test/resources/everything_config.toml
index e89442f7f78..ac8911d6269 100644
--- a/besu/src/test/resources/everything_config.toml
+++ b/besu/src/test/resources/everything_config.toml
@@ -220,6 +220,7 @@ bonsai-historical-block-limit=512
 bonsai-limit-trie-logs-enabled=true
 bonsai-trie-logs-pruning-window-size=100_000
 receipt-compaction-enabled=true
+hash-preimage-storage-enabled=true
 
 # feature flags
 Xsecp256k1-native-enabled=false
@@ -248,4 +249,4 @@ Xevm-jumpdest-cache-weight-kb=32000
 # plugins
 Xplugins-external-enabled=true
 plugins=["none"]
-plugin-continue-on-error=false
\ No newline at end of file
+plugin-continue-on-error=false
diff --git a/build.gradle b/build.gradle
index 4fe80600c2c..0864de25911 100644
--- a/build.gradle
+++ b/build.gradle
@@ -996,7 +996,7 @@ def calculateVersion() {
     return "${project.version}"
   } else {
     // If no version is supplied or it doesn't match the semantic versioning, calculate from git
-    println("Generating project version as supplied is version not semver: ${project.version}")
+    println("Generating project version as supplied version is not semver: ${project.version}")
     def gitDetails = getGitCommitDetails(7) // Adjust length as needed
     return "${gitDetails.date}-develop-${gitDetails.hash}"
   }
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueSegmentIdentifier.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueSegmentIdentifier.java
index 32e372cdecf..0738556149c 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueSegmentIdentifier.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueSegmentIdentifier.java
@@ -46,7 +46,8 @@ public enum KeyValueSegmentIdentifier implements SegmentIdentifier {
   BACKWARD_SYNC_CHAIN(new byte[] {15}),
   SNAPSYNC_MISSING_ACCOUNT_RANGE(new byte[] {16}),
   SNAPSYNC_ACCOUNT_TO_FIX(new byte[] {17}),
-  CHAIN_PRUNER_STATE(new byte[] {18});
+  CHAIN_PRUNER_STATE(new byte[] {18}),
+  HASH_PREIMAGE_STORE(new byte[] {19}, EnumSet.of(BONSAI), true, false, false);
 
   private final byte[] id;
   private final EnumSet<DataStorageFormat> formats;
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueStorageProviderBuilder.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueStorageProviderBuilder.java
index 47635c9d27a..2c4ab8bcf72 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueStorageProviderBuilder.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueStorageProviderBuilder.java
@@ -23,6 +23,9 @@
 import org.hyperledger.besu.plugin.services.storage.KeyValueStorageFactory;
 import org.hyperledger.besu.services.kvstore.LimitedInMemoryKeyValueStorage;
 
+import java.util.ArrayList;
+import java.util.EnumSet;
+
 public class KeyValueStorageProviderBuilder {
 
   private static final long DEFAULT_WORLD_STATE_PRE_IMAGE_CACHE_SIZE = 5_000L;
@@ -55,8 +58,18 @@ public KeyValueStorageProvider build() {
         "Cannot build a storage provider without the plugin common configuration.");
     checkNotNull(metricsSystem, "Cannot build a storage provider without a metrics system.");
 
+    // TODO: unhack this storage pre-init hack, maybe a memoized supplier
+    storageFactory.create(
+        new ArrayList<>(EnumSet.allOf(KeyValueSegmentIdentifier.class)),
+        commonConfiguration,
+        metricsSystem);
+
     final KeyValueStorage worldStatePreImageStorage =
-        new LimitedInMemoryKeyValueStorage(DEFAULT_WORLD_STATE_PRE_IMAGE_CACHE_SIZE);
+        commonConfiguration.getDataStorageConfiguration().getHashPreImageStorageEnabled()
+            ? storageFactory.create(
+                KeyValueSegmentIdentifier.HASH_PREIMAGE_STORE, commonConfiguration, metricsSystem)
+            : new LimitedInMemoryKeyValueStorage(DEFAULT_WORLD_STATE_PRE_IMAGE_CACHE_SIZE);
+    ;
 
     return new KeyValueStorageProvider(
         segments -> storageFactory.create(segments, commonConfiguration, metricsSystem),
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/WorldStatePreimageKeyValueStorage.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/WorldStatePreimageKeyValueStorage.java
index 8824b3ef827..51a72bf7604 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/WorldStatePreimageKeyValueStorage.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/WorldStatePreimageKeyValueStorage.java
@@ -25,6 +25,16 @@
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.units.bigints.UInt256;
 
+/**
+ * This store is used in Forest storage format, and expects to use an Updater to insert and commit
+ * changes to storage, adjacent to worldstate commits. By not being part of the worldstate
+ * transaction and commit data in this implementation can become out-of-sync (by failing to commit
+ * preimages by hash) on abnormal exits of besu.
+ *
+ * <p>This implementation remains here for the deprecated forest storage format, and should be
+ * retired along with Forest.
+ */
+@Deprecated
 public class WorldStatePreimageKeyValueStorage implements WorldStatePreimageStorage {
   private final KeyValueStorage keyValueStorage;
 
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiPreImageProxy.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiPreImageProxy.java
deleted file mode 100644
index 070e797a530..00000000000
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiPreImageProxy.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright contributors to Hyperledger Besu.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
-
-import org.hyperledger.besu.datatypes.Address;
-import org.hyperledger.besu.datatypes.Hash;
-import org.hyperledger.besu.ethereum.worldstate.WorldStatePreimageStorage;
-
-import java.util.Optional;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import org.apache.tuweni.bytes.Bytes;
-import org.apache.tuweni.bytes.Bytes32;
-import org.apache.tuweni.units.bigints.UInt256;
-
-/** Acts as both a Hasher and PreImageStorage for Bonsai storage format. */
-public interface BonsaiPreImageProxy extends WorldStatePreimageStorage {
-  /**
-   * If this value is not already present, save in preImage store and return the hash value.
-   *
-   * @param value value to hash
-   * @return Hash of value
-   */
-  Hash hashAndSavePreImage(Bytes value);
-
-  /**
-   * A caching PreImageProxy suitable for ReferenceTestWorldState which saves hashes in an unbounded
-   * BiMap.
-   */
-  class BonsaiReferenceTestPreImageProxy implements BonsaiPreImageProxy {
-    BiMap<Hash, Bytes> preImageCache = HashBiMap.create();
-
-    @Override
-    public synchronized Hash hashAndSavePreImage(final Bytes value) {
-      return preImageCache.inverse().computeIfAbsent(value, Hash::hash);
-    }
-
-    @Override
-    public Optional<UInt256> getStorageTrieKeyPreimage(final Bytes32 trieKey) {
-      return Optional.ofNullable(preImageCache.get(trieKey)).map(UInt256::fromBytes);
-    }
-
-    @Override
-    public Optional<Address> getAccountTrieKeyPreimage(final Bytes32 trieKey) {
-      return Optional.ofNullable(preImageCache.get(trieKey)).map(Address::wrap);
-    }
-
-    @Override
-    public Updater updater() {
-      throw new UnsupportedOperationException(
-          "BonsaiReferenceTestPreImageProxy does not implement an updater");
-    }
-  }
-}
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java
index 07ded9ddf61..159b626f9e8 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java
@@ -32,7 +32,6 @@
 import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
 import org.hyperledger.besu.ethereum.worldstate.StateTrieAccountValue;
 import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
-import org.hyperledger.besu.evm.account.AccountStorageEntry;
 import org.hyperledger.besu.plugin.services.MetricsSystem;
 import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
 import org.hyperledger.besu.plugin.services.storage.KeyValueStorage;
@@ -41,7 +40,6 @@
 import org.hyperledger.besu.plugin.services.storage.SegmentedKeyValueStorageTransaction;
 
 import java.util.List;
-import java.util.NavigableMap;
 import java.util.Optional;
 import java.util.function.Supplier;
 
@@ -156,11 +154,6 @@ public Optional<Bytes> getStorageValueByStorageSlotKey(
             composedWorldStateStorage);
   }
 
-  public NavigableMap<Bytes32, AccountStorageEntry> storageEntriesFrom(
-      final Hash addressHash, final Bytes32 startKeyHash, final int limit) {
-    throw new RuntimeException("Bonsai Tries does not currently support enumerating storage");
-  }
-
   public void upgradeToFullFlatDbMode() {
     flatDbStrategyProvider.upgradeToFullFlatDbMode(composedWorldStateStorage);
   }
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/CachingPreImageStorage.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/CachingPreImageStorage.java
new file mode 100644
index 00000000000..f5cc73e4d71
--- /dev/null
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/CachingPreImageStorage.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright contributors to Hyperledger Besu.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
+
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.Hash;
+
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import org.apache.tuweni.bytes.Bytes;
+import org.apache.tuweni.bytes.Bytes32;
+import org.apache.tuweni.units.bigints.UInt256;
+
+/** Acts as both a Hasher and PreImageStorage for Bonsai storage format. */
+public interface CachingPreImageStorage {
+
+  enum HashSource {
+    ACCOUNT_ADDRESS((byte) 0x00),
+    SLOT_KEY((byte) 0x01);
+    byte internal_type;
+
+    HashSource(final byte type) {
+      internal_type = type;
+    }
+
+    byte getTypeSuffix() {
+      return internal_type;
+    }
+
+    static HashSource wrap(final byte val) {
+      if (val == 0x00) {
+        return ACCOUNT_ADDRESS;
+      } else if (val == 0x01) {
+        return SLOT_KEY;
+      } else {
+        throw new NoSuchElementException(String.format("Value %x is not a preimage source", val));
+      }
+    }
+  }
+
+  record HashKey(Hash hashValue, HashSource source) {}
+
+  /**
+   * If this value is not already present, save in preImage store and return the hash value.
+   *
+   * @param value value to hash
+   * @return Hash of value
+   */
+  Hash hashAndSaveAddressPreImage(final Bytes value);
+
+  Hash hashAndSaveSlotKeyPreImage(final UInt256 keyUInt);
+
+  Stream<Address> streamAddressPreImages(final Bytes32 startKeyHash, final int limit);
+
+  Optional<UInt256> getStorageTrieKeyPreimage(final Bytes32 trieKey);
+
+  Optional<Address> getAccountTrieKeyPreimage(final Bytes32 trieKey);
+
+  Optional<Bytes> getRawHashPreImage(final Hash hash);
+
+  /**
+   * This method indicates whether this Pre-Image store is "complete", meaning it has all of the
+   * hash preimages for all entries in the state trie.
+   *
+   * @return boolean indicating whether the pre-image store is complete or not
+   */
+  default boolean canSupportStreaming() {
+    return false;
+  }
+
+  /**
+   * A caching PreImageProxy suitable for ReferenceTestWorldState which saves hashes in an unbounded
+   * BiMap.
+   */
+  class UnboundedPreImageStorage implements CachingPreImageStorage {
+    BiMap<HashKey, Bytes> preImageCache = HashBiMap.create();
+
+    @Override
+    public Hash hashAndSaveAddressPreImage(final Bytes value) {
+      return preImageCache
+          .inverse()
+          .computeIfAbsent(
+              value, v -> new HashKey(Address.wrap(v).addressHash(), HashSource.ACCOUNT_ADDRESS))
+          .hashValue();
+    }
+
+    @Override
+    public Hash hashAndSaveSlotKeyPreImage(final UInt256 value) {
+      return preImageCache
+          .inverse()
+          .computeIfAbsent(value, v -> new HashKey(Hash.hash(v), HashSource.SLOT_KEY))
+          .hashValue();
+    }
+
+    @Override
+    public Stream<Address> streamAddressPreImages(final Bytes32 startKeyHash, final int limit) {
+      final Hash startHash = Hash.wrap(startKeyHash);
+      return preImageCache.entrySet().stream()
+          .filter(entry -> entry.getKey().source() == HashSource.ACCOUNT_ADDRESS)
+          .filter(entry -> entry.getKey().hashValue().compareTo(startHash) >= 0)
+          .map(e -> Address.wrap(e.getValue()))
+          .limit(limit);
+    }
+
+    @Override
+    public Optional<UInt256> getStorageTrieKeyPreimage(final Bytes32 trieKey) {
+      return Optional.ofNullable(
+              preImageCache.get(new HashKey(Hash.wrap(trieKey), HashSource.SLOT_KEY)))
+          .map(UInt256::fromBytes);
+    }
+
+    @Override
+    public Optional<Address> getAccountTrieKeyPreimage(final Bytes32 trieKey) {
+      return Optional.ofNullable(
+              preImageCache.get(new HashKey(Hash.wrap(trieKey), HashSource.ACCOUNT_ADDRESS)))
+          .map(Address::wrap);
+    }
+
+    @Override
+    public Optional<Bytes> getRawHashPreImage(final Hash hash) {
+      return Stream.of(
+              preImageCache.get(new HashKey(hash, HashSource.ACCOUNT_ADDRESS)),
+              preImageCache.get(new HashKey(hash, HashSource.SLOT_KEY)))
+          .filter(Objects::nonNull)
+          .findAny();
+    }
+
+    @Override
+    public boolean canSupportStreaming() {
+      return true;
+    }
+  }
+
+  class CachingOnlyPreImageStorage implements CachingPreImageStorage {
+
+    // TODO: config max size perhaps
+    private static final Cache<Bytes, Hash> preimageCache =
+        Caffeine.newBuilder().maximumSize(10000).build();
+
+    @Override
+    public Hash hashAndSaveAddressPreImage(final Bytes value) {
+      // defer to the static Address hash map used by the evm
+      return preimageCache.get(value, v -> Address.wrap(value).addressHash());
+    }
+
+    @Override
+    public Hash hashAndSaveSlotKeyPreImage(final UInt256 keyUInt) {
+      return preimageCache.get(keyUInt, Hash::hash);
+    }
+
+    @Override
+    public Stream<Address> streamAddressPreImages(final Bytes32 startKeyHash, final int limit) {
+      // not configured for preimage streaming
+      return Stream.empty();
+    }
+
+    @Override
+    public Optional<UInt256> getStorageTrieKeyPreimage(final Bytes32 trieKey) {
+      return getRawHashPreImage(Hash.wrap(trieKey)).map(UInt256::fromBytes);
+    }
+
+    @Override
+    public Optional<Address> getAccountTrieKeyPreimage(final Bytes32 trieKey) {
+      return getRawHashPreImage(Hash.wrap(trieKey)).map(Address::wrap);
+    }
+
+    @Override
+    public Optional<Bytes> getRawHashPreImage(final Hash hash) {
+      return preimageCache.asMap().entrySet().stream()
+          .filter(e -> e.getValue().equals(hash))
+          .findFirst()
+          .map(Map.Entry::getKey);
+    }
+  }
+}
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldState.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldState.java
index b62805c1fda..d43f585b45d 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldState.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldState.java
@@ -192,7 +192,7 @@ private void updateTheAccounts(
       final BonsaiAccount updatedAccount = bonsaiValue.getUpdated();
       try {
         if (updatedAccount == null) {
-          final Hash addressHash = hashAndSavePreImage(accountKey);
+          final Hash addressHash = getPreImageProxy().hashAndSaveAddressPreImage(accountKey);
           accountTrie.remove(addressHash);
           maybeStateUpdater.ifPresent(
               bonsaiUpdater -> bonsaiUpdater.removeAccountInfoState(addressHash));
@@ -201,7 +201,8 @@ private void updateTheAccounts(
           final Bytes accountValue = updatedAccount.serializeAccount();
           maybeStateUpdater.ifPresent(
               bonsaiUpdater ->
-                  bonsaiUpdater.putAccountInfoState(hashAndSavePreImage(accountKey), accountValue));
+                  bonsaiUpdater.putAccountInfoState(
+                      getPreImageProxy().hashAndSaveAddressPreImage(accountKey), accountValue));
           accountTrie.put(addressHash, accountValue);
         }
       } catch (MerkleTrieException e) {
@@ -434,6 +435,11 @@ public Optional<UInt256> getStorageValueByStorageSlotKey(
         .map(UInt256::fromBytes);
   }
 
+  @Override
+  public Stream<StreamableAccount> streamAccounts(final Bytes32 startKeyHash, final int limit) {
+    return worldStateKeyValueStorage.streamAccounts(this, startKeyHash, limit);
+  }
+
   @Override
   public UInt256 getPriorStorageValue(final Address address, final UInt256 storageKey) {
     return getStorageValue(address, storageKey);
@@ -463,11 +469,6 @@ private MerkleTrie<Bytes, Bytes> createTrie(final NodeLoader nodeLoader, final B
     }
   }
 
-  protected Hash hashAndSavePreImage(final Bytes value) {
-    // by default do not save has preImages
-    return Hash.hash(value);
-  }
-
   @Override
   protected Hash getEmptyTrieHash() {
     return Hash.EMPTY_TRIE_HASH;
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedWorldStateKeyValueStorage.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedWorldStateKeyValueStorage.java
index 50adf7b34fe..4043089fc62 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedWorldStateKeyValueStorage.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedWorldStateKeyValueStorage.java
@@ -19,13 +19,19 @@
 import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.CODE_STORAGE;
 import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.TRIE_BRANCH_STORAGE;
 
+import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.ethereum.storage.StorageProvider;
 import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.CachingPreImageStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategy;
+import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
 import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
 import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
+import org.hyperledger.besu.evm.account.AccountStorageEntry;
+import org.hyperledger.besu.evm.worldstate.WorldState;
 import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
 import org.hyperledger.besu.plugin.services.storage.KeyValueStorage;
 import org.hyperledger.besu.plugin.services.storage.KeyValueStorageTransaction;
@@ -34,16 +40,22 @@
 import org.hyperledger.besu.util.Subscribers;
 
 import java.nio.charset.StandardCharsets;
+import java.util.Comparator;
 import java.util.List;
+import java.util.Map;
 import java.util.NavigableMap;
 import java.util.Optional;
+import java.util.TreeMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import kotlin.Pair;
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.bytes.Bytes32;
+import org.apache.tuweni.rlp.RLP;
+import org.apache.tuweni.units.bigints.UInt256;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -52,6 +64,11 @@ public abstract class DiffBasedWorldStateKeyValueStorage
   private static final Logger LOG =
       LoggerFactory.getLogger(DiffBasedWorldStateKeyValueStorage.class);
 
+  // TODO: config this based on dataStorageConfiguration, use real storage where appropriate
+  //   currently hard-coded to Unbounded preimage store so ref/spec tests pass
+  private static final CachingPreImageStorage preImageProxy =
+      new CachingPreImageStorage.UnboundedPreImageStorage();
+
   // 0x776f726c64526f6f74
   public static final byte[] WORLD_ROOT_HASH_KEY = "worldRoot".getBytes(StandardCharsets.UTF_8);
   // 0x776f726c64426c6f636b48617368
@@ -93,6 +110,10 @@ public SegmentedKeyValueStorage getComposedWorldStateStorage() {
     return composedWorldStateStorage;
   }
 
+  public CachingPreImageStorage getPreImageProxy() {
+    return preImageProxy;
+  }
+
   public KeyValueStorage getTrieLogStorage() {
     return trieLogStorage;
   }
@@ -157,6 +178,53 @@ public boolean isWorldStateAvailable(final Bytes32 rootHash, final Hash blockHas
         .orElse(false);
   }
 
+  public NavigableMap<Bytes32, AccountStorageEntry> storageEntriesFrom(
+      final Hash addressHash, final Bytes32 startKeyHash, final int limit) {
+    if (preImageProxy != null && preImageProxy.canSupportStreaming()) {
+      return streamFlatStorages(addressHash, startKeyHash, UInt256.MAX_VALUE, limit)
+          .entrySet()
+          // map back to slot keys using preImage provider:
+          .stream()
+          .collect(
+              Collectors.toMap(
+                  Map.Entry::getKey,
+                  e ->
+                      AccountStorageEntry.create(
+                          UInt256.fromBytes(RLP.decodeValue(e.getValue())),
+                          Hash.wrap(e.getKey()),
+                          preImageProxy.getStorageTrieKeyPreimage(e.getKey())),
+                  (a, b) -> a,
+                  TreeMap::new));
+    }
+    throw new RuntimeException("Not configured to support enumerating storage");
+  }
+
+  public Stream<WorldState.StreamableAccount> streamAccounts(
+      final DiffBasedWorldView context, final Bytes32 startKeyHash, final int limit) {
+    if (preImageProxy.canSupportStreaming()) {
+      return streamFlatAccounts(startKeyHash, UInt256.MAX_VALUE, limit)
+          .entrySet()
+          // map back to addresses using preImage provider:
+          .stream()
+          .map(
+              entry ->
+                  preImageProxy
+                      .getAccountTrieKeyPreimage(entry.getKey())
+                      .map(
+                          address ->
+                              new WorldState.StreamableAccount(
+                                  Optional.of(address),
+                                  BonsaiAccount.fromRLP(
+                                      context, address, entry.getValue(), false))))
+          .filter(Optional::isPresent)
+          .map(Optional::get)
+          .filter(acct -> context.updater().getAccount(acct.getAddress().orElse(null)) != null)
+          .sorted(Comparator.comparing(account -> account.getAddress().orElse(Address.ZERO)));
+    } else {
+      throw new RuntimeException("Not configured to support enumerating accounts");
+    }
+  }
+
   @Override
   public void clear() {
     subscribers.forEach(StorageSubscriber::onClearStorage);
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldState.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldState.java
index 76a8fbd6377..5eacb87f777 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldState.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldState.java
@@ -23,6 +23,7 @@
 import org.hyperledger.besu.datatypes.StorageSlotKey;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.MutableWorldState;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.CachingPreImageStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.cache.DiffBasedCachedWorldStorageManager;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedLayeredWorldStateKeyValueStorage;
@@ -117,6 +118,11 @@ private boolean isPersisted(final WorldStateKeyValueStorage worldStateKeyValueSt
     return !(worldStateKeyValueStorage instanceof DiffBasedSnapshotWorldStateKeyValueStorage);
   }
 
+  @Override
+  public CachingPreImageStorage getPreImageProxy() {
+    return worldStateKeyValueStorage.getPreImageProxy();
+  }
+
   /**
    * Reset the worldState to this block header
    *
@@ -295,9 +301,14 @@ public Hash blockHash() {
   }
 
   @Override
-  public Stream<StreamableAccount> streamAccounts(final Bytes32 startKeyHash, final int limit) {
-    throw new RuntimeException("storage format do not provide account streaming.");
-  }
+  public abstract Stream<StreamableAccount> streamAccounts(
+      final Bytes32 startKeyHash, final int limit);
+
+  //  {
+  //    return preImageProxy
+  //        .streamAddressPreImages(startKeyHash, limit)
+  //        .map(address -> new StreamableAccount(Optional.of(address), get(address)));
+  //  }
 
   @Override
   public UInt256 getPriorStorageValue(final Address address, final UInt256 storageKey) {
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldView.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldView.java
index 7ecc49e2863..49d72c6a11d 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldView.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldView.java
@@ -18,6 +18,7 @@
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.datatypes.StorageSlotKey;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.CachingPreImageStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 import org.hyperledger.besu.evm.worldstate.WorldView;
@@ -57,6 +58,9 @@ static Bytes encodeTrieValue(final Bytes bytes) {
 
   boolean isPersisted();
 
+  // TODO: comments and naming
+  CachingPreImageStorage getPreImageProxy();
+
   DiffBasedWorldStateKeyValueStorage getWorldStateStorage();
 
   WorldUpdater updater();
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/DiffBasedWorldStateUpdateAccumulator.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/DiffBasedWorldStateUpdateAccumulator.java
index c28bb731b5b..efa9002f7ad 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/DiffBasedWorldStateUpdateAccumulator.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/DiffBasedWorldStateUpdateAccumulator.java
@@ -21,6 +21,7 @@
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.rlp.RLP;
 import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.CachingPreImageStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedAccount;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
@@ -74,7 +75,6 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
   private final Map<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>>
       storageToUpdate = new ConcurrentHashMap<>();
 
-  private final Map<UInt256, Hash> storageKeyHashLookup = new ConcurrentHashMap<>();
   protected boolean isAccumulatorStateChanged;
 
   public DiffBasedWorldStateUpdateAccumulator(
@@ -480,7 +480,8 @@ public void commit() {
                         final UInt256 keyUInt = storageUpdate.getKey();
                         final StorageSlotKey slotKey =
                             new StorageSlotKey(
-                                hashAndSaveSlotPreImage(keyUInt), Optional.of(keyUInt));
+                                world.getPreImageProxy().hashAndSaveSlotKeyPreImage(keyUInt),
+                                Optional.of(keyUInt));
                         final UInt256 value = storageUpdate.getValue();
                         final DiffBasedValue<UInt256> pendingValue =
                             pendingStorageUpdates.get(slotKey);
@@ -524,7 +525,8 @@ public Optional<Bytes> getCode(final Address address, final Hash codeHash) {
   @Override
   public UInt256 getStorageValue(final Address address, final UInt256 slotKey) {
     StorageSlotKey storageSlotKey =
-        new StorageSlotKey(hashAndSaveSlotPreImage(slotKey), Optional.of(slotKey));
+        new StorageSlotKey(
+            world.getPreImageProxy().hashAndSaveSlotKeyPreImage(slotKey), Optional.of(slotKey));
     return getStorageValueByStorageSlotKey(address, storageSlotKey).orElse(UInt256.ZERO);
   }
 
@@ -563,7 +565,9 @@ public Optional<UInt256> getStorageValueByStorageSlotKey(
   public UInt256 getPriorStorageValue(final Address address, final UInt256 storageKey) {
     // TODO maybe log the read into the trie layer?
     StorageSlotKey storageSlotKey =
-        new StorageSlotKey(hashAndSaveSlotPreImage(storageKey), Optional.of(storageKey));
+        new StorageSlotKey(
+            world.getPreImageProxy().hashAndSaveSlotKeyPreImage(storageKey),
+            Optional.of(storageKey));
     final Map<StorageSlotKey, DiffBasedValue<UInt256>> localAccountStorage =
         storageToUpdate.get(address);
     if (localAccountStorage != null) {
@@ -611,6 +615,11 @@ public DiffBasedWorldStateKeyValueStorage getWorldStateStorage() {
     return wrappedWorldView().getWorldStateStorage();
   }
 
+  @Override
+  public CachingPreImageStorage getPreImageProxy() {
+    return wrappedWorldView().getPreImageProxy();
+  }
+
   public void rollForward(final TrieLog layer) {
     layer
         .getAccountChanges()
@@ -874,21 +883,11 @@ public void reset() {
     resetAccumulatorStateChanged();
     updatedAccounts.clear();
     deletedAccounts.clear();
-    storageKeyHashLookup.clear();
   }
 
   protected Hash hashAndSaveAccountPreImage(final Address address) {
-    // no need to save account preimage by default
-    return Hash.hash(address);
-  }
-
-  protected Hash hashAndSaveSlotPreImage(final UInt256 slotKey) {
-    Hash hash = storageKeyHashLookup.get(slotKey);
-    if (hash == null) {
-      hash = Hash.hash(slotKey);
-      storageKeyHashLookup.put(slotKey, hash);
-    }
-    return hash;
+    // default to using address static hash cache:
+    return getPreImageProxy().hashAndSaveAddressPreImage(address);
   }
 
   public abstract DiffBasedWorldStateUpdateAccumulator<ACCOUNT> copy();
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DataStorageConfiguration.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DataStorageConfiguration.java
index 9ce059e94c2..9197527feeb 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DataStorageConfiguration.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DataStorageConfiguration.java
@@ -21,9 +21,11 @@
 
 @Value.Immutable
 @Value.Enclosing
-public interface DataStorageConfiguration {
+public interface DataStorageConfiguration
+    extends org.hyperledger.besu.plugin.services.storage.DataStorageConfiguration {
 
   boolean DEFAULT_RECEIPT_COMPACTION_ENABLED = true;
+  boolean DEFAULT_HASH_PREIMAGE_STORAGE_ENABLED = false;
 
   DataStorageConfiguration DEFAULT_CONFIG =
       ImmutableDataStorageConfiguration.builder()
@@ -48,6 +50,7 @@ public interface DataStorageConfiguration {
           .diffBasedSubStorageConfiguration(DiffBasedSubStorageConfiguration.DISABLED)
           .build();
 
+  @Override
   DataStorageFormat getDataStorageFormat();
 
   @Value.Default
@@ -56,6 +59,13 @@ default DiffBasedSubStorageConfiguration getDiffBasedSubStorageConfiguration() {
   }
 
   @Value.Default
+  @Override
+  default boolean getHashPreImageStorageEnabled() {
+    return DEFAULT_HASH_PREIMAGE_STORAGE_ENABLED;
+  }
+
+  @Value.Default
+  @Override
   default boolean getReceiptCompactionEnabled() {
     return DEFAULT_RECEIPT_COMPACTION_ENABLED;
   }
diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStatePreimageStorage.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStatePreimageStorage.java
index fe8e1ac2ac5..fde6572aa8e 100644
--- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStatePreimageStorage.java
+++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStatePreimageStorage.java
@@ -21,6 +21,7 @@
 import org.apache.tuweni.bytes.Bytes32;
 import org.apache.tuweni.units.bigints.UInt256;
 
+/** Standalone preimage storage implementation. */
 public interface WorldStatePreimageStorage {
 
   Optional<UInt256> getStorageTrieKeyPreimage(Bytes32 trieKey);
diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/AbstractIsolationTests.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/AbstractIsolationTests.java
index dd9257441e8..a07768e0e8e 100644
--- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/AbstractIsolationTests.java
+++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/AbstractIsolationTests.java
@@ -237,7 +237,7 @@ public Wei getMinGasPrice() {
                   getDataStorageConfiguration() {
                 return new org.hyperledger.besu.plugin.services.storage.DataStorageConfiguration() {
                   @Override
-                  public DataStorageFormat getDatabaseFormat() {
+                  public DataStorageFormat getDataStorageFormat() {
                     return DataStorageFormat.BONSAI;
                   }
 
@@ -245,6 +245,11 @@ public DataStorageFormat getDatabaseFormat() {
                   public boolean getReceiptCompactionEnabled() {
                     return false;
                   }
+
+                  @Override
+                  public boolean getHashPreImageStorageEnabled() {
+                    return false;
+                  }
                 };
               }
             })
diff --git a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestUpdateAccumulator.java b/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestUpdateAccumulator.java
index db8bb4b3e9e..26682c688bc 100644
--- a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestUpdateAccumulator.java
+++ b/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestUpdateAccumulator.java
@@ -14,11 +14,8 @@
  */
 package org.hyperledger.besu.ethereum.referencetests;
 
-import org.hyperledger.besu.datatypes.Address;
-import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.datatypes.StorageSlotKey;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiPreImageProxy;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldStateUpdateAccumulator;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
@@ -31,36 +28,19 @@
 import org.apache.tuweni.units.bigints.UInt256;
 
 public class BonsaiReferenceTestUpdateAccumulator extends BonsaiWorldStateUpdateAccumulator {
-  private final BonsaiPreImageProxy preImageProxy;
 
   public BonsaiReferenceTestUpdateAccumulator(
       final DiffBasedWorldView world,
       final Consumer<DiffBasedValue<BonsaiAccount>> accountPreloader,
       final Consumer<StorageSlotKey> storagePreloader,
-      final BonsaiPreImageProxy preImageProxy,
       final EvmConfiguration evmConfiguration) {
     super(world, accountPreloader, storagePreloader, evmConfiguration);
-    this.preImageProxy = preImageProxy;
-  }
-
-  @Override
-  protected Hash hashAndSaveAccountPreImage(final Address address) {
-    return preImageProxy.hashAndSavePreImage(address);
-  }
-
-  @Override
-  protected Hash hashAndSaveSlotPreImage(final UInt256 slotKey) {
-    return preImageProxy.hashAndSavePreImage(slotKey);
   }
 
   public BonsaiReferenceTestUpdateAccumulator createDetachedAccumulator() {
     final BonsaiReferenceTestUpdateAccumulator copy =
         new BonsaiReferenceTestUpdateAccumulator(
-            wrappedWorldView(),
-            accountPreloader,
-            storagePreloader,
-            preImageProxy,
-            evmConfiguration);
+            wrappedWorldView(), accountPreloader, storagePreloader, evmConfiguration);
     getAccountsToUpdate().forEach((k, v) -> copy.getAccountsToUpdate().put(k, v.copy()));
     getCodeToUpdate().forEach((k, v) -> copy.getCodeToUpdate().put(k, v.copy()));
     copy.getStorageToClear().addAll(getStorageToClear());
diff --git a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldState.java b/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldState.java
index e374f5c020f..8fb5ce70794 100644
--- a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldState.java
+++ b/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldState.java
@@ -20,7 +20,6 @@
 import org.hyperledger.besu.ethereum.core.InMemoryKeyValueStorageProvider;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.NoOpBonsaiCachedWorldStorageManager;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiPreImageProxy;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateLayerStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
@@ -40,27 +39,21 @@
 
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Stream;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
-import org.apache.tuweni.bytes.Bytes;
-import org.apache.tuweni.bytes.Bytes32;
 
 public class BonsaiReferenceTestWorldState extends BonsaiWorldState
     implements ReferenceTestWorldState {
 
-  private final BonsaiReferenceTestWorldStateStorage refTestStorage;
-  private final BonsaiPreImageProxy preImageProxy;
   private final EvmConfiguration evmConfiguration;
 
   protected BonsaiReferenceTestWorldState(
-      final BonsaiReferenceTestWorldStateStorage worldStateKeyValueStorage,
+      final BonsaiWorldStateLayerStorage worldStateKeyValueStorage,
       final BonsaiCachedMerkleTrieLoader bonsaiCachedMerkleTrieLoader,
       final DiffBasedCachedWorldStorageManager cachedWorldStorageManager,
       final TrieLogManager trieLogManager,
-      final BonsaiPreImageProxy preImageProxy,
       final EvmConfiguration evmConfiguration) {
     super(
         worldStateKeyValueStorage,
@@ -69,8 +62,6 @@ protected BonsaiReferenceTestWorldState(
         trieLogManager,
         evmConfiguration,
         new DiffBasedWorldStateConfig());
-    this.refTestStorage = worldStateKeyValueStorage;
-    this.preImageProxy = preImageProxy;
     this.evmConfiguration = evmConfiguration;
     setAccumulator(
         new BonsaiReferenceTestUpdateAccumulator(
@@ -81,19 +72,17 @@ protected BonsaiReferenceTestWorldState(
             (addr, value) ->
                 bonsaiCachedMerkleTrieLoader.preLoadStorageSlot(
                     getWorldStateStorage(), addr, value),
-            preImageProxy,
             evmConfiguration));
   }
 
   @Override
   public ReferenceTestWorldState copy() {
-    var layerCopy = new BonsaiReferenceTestWorldStateStorage(getWorldStateStorage(), preImageProxy);
+    var layerCopy = new BonsaiWorldStateLayerStorage(getWorldStateStorage());
     return new BonsaiReferenceTestWorldState(
         layerCopy,
         bonsaiCachedMerkleTrieLoader,
         cachedWorldStorageManager,
         trieLogManager,
-        preImageProxy,
         evmConfiguration);
   }
 
@@ -220,17 +209,14 @@ public static BonsaiReferenceTestWorldState create(
         new BonsaiCachedMerkleTrieLoader(metricsSystem);
     final TrieLogManager trieLogManager = new ReferenceTestsInMemoryTrieLogManager();
 
-    final BonsaiPreImageProxy preImageProxy =
-        new BonsaiPreImageProxy.BonsaiReferenceTestPreImageProxy();
-
     final BonsaiWorldStateKeyValueStorage bonsaiWorldStateKeyValueStorage =
         new BonsaiWorldStateKeyValueStorage(
             new InMemoryKeyValueStorageProvider(),
             metricsSystem,
             DataStorageConfiguration.DEFAULT_BONSAI_CONFIG);
 
-    final BonsaiReferenceTestWorldStateStorage worldStateKeyValueStorage =
-        new BonsaiReferenceTestWorldStateStorage(bonsaiWorldStateKeyValueStorage, preImageProxy);
+    final BonsaiWorldStateLayerStorage worldStateKeyValueStorage =
+        new BonsaiWorldStateLayerStorage(bonsaiWorldStateKeyValueStorage);
 
     final NoOpBonsaiCachedWorldStorageManager noOpCachedWorldStorageManager =
         new NoOpBonsaiCachedWorldStorageManager(bonsaiWorldStateKeyValueStorage);
@@ -241,7 +227,6 @@ public static BonsaiReferenceTestWorldState create(
             bonsaiCachedMerkleTrieLoader,
             noOpCachedWorldStorageManager,
             trieLogManager,
-            preImageProxy,
             evmConfiguration);
 
     final WorldUpdater updater = worldState.updater();
@@ -253,11 +238,6 @@ public static BonsaiReferenceTestWorldState create(
     return worldState;
   }
 
-  @Override
-  public Stream<StreamableAccount> streamAccounts(final Bytes32 startKeyHash, final int limit) {
-    return this.refTestStorage.streamAccounts(this, startKeyHash, limit);
-  }
-
   static class ReferenceTestsInMemoryTrieLogManager extends TrieLogManager {
 
     private final Cache<Hash, byte[]> trieLogCache =
@@ -291,10 +271,4 @@ public Optional<TrieLog> getTrieLogLayer(final Hash blockHash) {
       return Optional.ofNullable(trieLogFactory.deserialize(trielog));
     }
   }
-
-  @Override
-  protected Hash hashAndSavePreImage(final Bytes value) {
-    // by default do not save has preImages
-    return preImageProxy.hashAndSavePreImage(value);
-  }
 }
diff --git a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldStateStorage.java b/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldStateStorage.java
deleted file mode 100644
index 3d059097810..00000000000
--- a/ethereum/referencetests/src/main/java/org/hyperledger/besu/ethereum/referencetests/BonsaiReferenceTestWorldStateStorage.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright contributors to Hyperledger Besu.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-package org.hyperledger.besu.ethereum.referencetests;
-
-import org.hyperledger.besu.datatypes.Address;
-import org.hyperledger.besu.datatypes.Hash;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiPreImageProxy;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateLayerStorage;
-import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
-import org.hyperledger.besu.evm.account.AccountStorageEntry;
-import org.hyperledger.besu.evm.worldstate.WorldState;
-
-import java.util.Comparator;
-import java.util.Map;
-import java.util.NavigableMap;
-import java.util.Optional;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import org.apache.tuweni.bytes.Bytes32;
-import org.apache.tuweni.rlp.RLP;
-import org.apache.tuweni.units.bigints.UInt256;
-
-public class BonsaiReferenceTestWorldStateStorage extends BonsaiWorldStateLayerStorage {
-  private final BonsaiPreImageProxy preImageProxy;
-
-  public BonsaiReferenceTestWorldStateStorage(
-      final BonsaiWorldStateKeyValueStorage parent, final BonsaiPreImageProxy preImageProxy) {
-    super(parent);
-    this.preImageProxy = preImageProxy;
-  }
-
-  @Override
-  public NavigableMap<Bytes32, AccountStorageEntry> storageEntriesFrom(
-      final Hash addressHash, final Bytes32 startKeyHash, final int limit) {
-    return streamFlatStorages(addressHash, startKeyHash, UInt256.MAX_VALUE, limit)
-        .entrySet()
-        // map back to slot keys using preImage provider:
-        .stream()
-        .collect(
-            Collectors.toMap(
-                Map.Entry::getKey,
-                e ->
-                    AccountStorageEntry.create(
-                        UInt256.fromBytes(RLP.decodeValue(e.getValue())),
-                        Hash.wrap(e.getKey()),
-                        preImageProxy.getStorageTrieKeyPreimage(e.getKey())),
-                (a, b) -> a,
-                TreeMap::new));
-  }
-
-  public Stream<WorldState.StreamableAccount> streamAccounts(
-      final DiffBasedWorldView context, final Bytes32 startKeyHash, final int limit) {
-    return streamFlatAccounts(startKeyHash, UInt256.MAX_VALUE, limit)
-        .entrySet()
-        // map back to addresses using preImage provider:
-        .stream()
-        .map(
-            entry ->
-                preImageProxy
-                    .getAccountTrieKeyPreimage(entry.getKey())
-                    .map(
-                        address ->
-                            new WorldState.StreamableAccount(
-                                Optional.of(address),
-                                BonsaiAccount.fromRLP(context, address, entry.getValue(), false))))
-        .filter(Optional::isPresent)
-        .map(Optional::get)
-        .filter(acct -> context.updater().getAccount(acct.getAddress().orElse(null)) != null)
-        .sorted(Comparator.comparing(account -> account.getAddress().orElse(Address.ZERO)));
-  }
-}
diff --git a/evm/src/main/java/org/hyperledger/besu/evm/worldstate/AbstractWorldUpdater.java b/evm/src/main/java/org/hyperledger/besu/evm/worldstate/AbstractWorldUpdater.java
index 9623eaf89ed..59db669495b 100644
--- a/evm/src/main/java/org/hyperledger/besu/evm/worldstate/AbstractWorldUpdater.java
+++ b/evm/src/main/java/org/hyperledger/besu/evm/worldstate/AbstractWorldUpdater.java
@@ -40,7 +40,9 @@
 public abstract class AbstractWorldUpdater<W extends WorldView, A extends Account>
     implements WorldUpdater {
 
-  private final W world;
+  /** The worldview associated with this updater. */
+  protected final W world;
+
   private final EvmConfiguration evmConfiguration;
 
   /** The Updated accounts. */
diff --git a/plugin-api/build.gradle b/plugin-api/build.gradle
index d400e5abe22..5859e49e7c2 100644
--- a/plugin-api/build.gradle
+++ b/plugin-api/build.gradle
@@ -71,7 +71,7 @@ Calculated : ${currentHash}
 tasks.register('checkAPIChanges', FileStateChecker) {
   description = "Checks that the API for the Plugin-API project does not change without deliberate thought"
   files = sourceSets.main.allJava.files
-  knownHash = '1VIGlJuGiaEVUksIjTTHDt7SIjjJE9+DU8rYk/ze3XM='
+  knownHash = 'qXX4LwLi4ibYNDrXEUEFfNWCvUpcibJyeBBeltWo99k='
 }
 check.dependsOn('checkAPIChanges')
 
diff --git a/plugin-api/src/main/java/org/hyperledger/besu/plugin/services/storage/DataStorageConfiguration.java b/plugin-api/src/main/java/org/hyperledger/besu/plugin/services/storage/DataStorageConfiguration.java
index 22fdf922f3e..ba69da3d63d 100644
--- a/plugin-api/src/main/java/org/hyperledger/besu/plugin/services/storage/DataStorageConfiguration.java
+++ b/plugin-api/src/main/java/org/hyperledger/besu/plugin/services/storage/DataStorageConfiguration.java
@@ -26,7 +26,7 @@ public interface DataStorageConfiguration {
    * @return Database format.
    */
   @Unstable
-  DataStorageFormat getDatabaseFormat();
+  DataStorageFormat getDataStorageFormat();
 
   /**
    * Whether receipt compaction is enabled. When enabled this reduces the storage needed for
@@ -36,4 +36,13 @@ public interface DataStorageConfiguration {
    */
   @Unstable
   boolean getReceiptCompactionEnabled();
+
+  /**
+   * Indicates whether to persist hash preimages to storage. When enabled this option will persist
+   * Account and Hash preimages to storage upon their writing.
+   *
+   * @return whether preimage persistent storage is enabled
+   */
+  @Unstable
+  boolean getHashPreImageStorageEnabled();
 }
diff --git a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactory.java b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactory.java
index d53c9e57fde..3de0fd0286c 100644
--- a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactory.java
+++ b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactory.java
@@ -222,7 +222,7 @@ private DatabaseMetadata readDatabaseMetadata(final BesuConfiguration commonConf
       if (!metadata
           .getVersionedStorageFormat()
           .getFormat()
-          .equals(commonConfiguration.getDataStorageConfiguration().getDatabaseFormat())) {
+          .equals(commonConfiguration.getDataStorageConfiguration().getDataStorageFormat())) {
         handleFormatMismatch(commonConfiguration, dataDir, metadata);
       }
 
@@ -278,7 +278,7 @@ private static void handleFormatMismatch(
                 + "Please check your config.",
             dataDir,
             existingMetadata.getVersionedStorageFormat().getFormat().name(),
-            commonConfiguration.getDataStorageConfiguration().getDatabaseFormat());
+            commonConfiguration.getDataStorageConfiguration().getDataStorageFormat());
 
     throw new StorageException(error);
   }
diff --git a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/BaseVersionedStorageFormat.java b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/BaseVersionedStorageFormat.java
index ad3557636d2..8fbe7e43bce 100644
--- a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/BaseVersionedStorageFormat.java
+++ b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/BaseVersionedStorageFormat.java
@@ -62,7 +62,7 @@ public enum BaseVersionedStorageFormat implements VersionedStorageFormat {
    */
   public static BaseVersionedStorageFormat defaultForNewDB(
       final DataStorageConfiguration configuration) {
-    return switch (configuration.getDatabaseFormat()) {
+    return switch (configuration.getDataStorageFormat()) {
       case FOREST -> FOREST_WITH_RECEIPT_COMPACTION;
       case BONSAI -> BONSAI_WITH_RECEIPT_COMPACTION;
     };
diff --git a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/PrivacyVersionedStorageFormat.java b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/PrivacyVersionedStorageFormat.java
index ca5988dc75f..ef7a97b883c 100644
--- a/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/PrivacyVersionedStorageFormat.java
+++ b/plugins/rocksdb/src/main/java/org/hyperledger/besu/plugin/services/storage/rocksdb/configuration/PrivacyVersionedStorageFormat.java
@@ -63,7 +63,7 @@ public enum PrivacyVersionedStorageFormat implements VersionedStorageFormat {
    */
   public static VersionedStorageFormat defaultForNewDB(
       final DataStorageConfiguration configuration) {
-    return switch (configuration.getDatabaseFormat()) {
+    return switch (configuration.getDataStorageFormat()) {
       case FOREST -> FOREST_WITH_RECEIPT_COMPACTION;
       case BONSAI -> BONSAI_WITH_RECEIPT_COMPACTION;
     };
diff --git a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/NearestKeyValueStorageTest.java b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/NearestKeyValueStorageTest.java
index 54cd03215fc..e69cb22de64 100644
--- a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/NearestKeyValueStorageTest.java
+++ b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/NearestKeyValueStorageTest.java
@@ -310,7 +310,7 @@ private static void mockCommonConfiguration(final Path tempDataDir) {
     when(commonConfiguration.getStoragePath()).thenReturn(tempDataDir);
     when(commonConfiguration.getDataPath()).thenReturn(tempDataDir);
     DataStorageConfiguration dataStorageConfiguration = mock(DataStorageConfiguration.class);
-    when(dataStorageConfiguration.getDatabaseFormat()).thenReturn(DataStorageFormat.BONSAI);
+    when(dataStorageConfiguration.getDataStorageFormat()).thenReturn(DataStorageFormat.BONSAI);
     lenient()
         .when(commonConfiguration.getDataStorageConfiguration())
         .thenReturn(dataStorageConfiguration);
diff --git a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValuePrivacyStorageFactoryTest.java b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValuePrivacyStorageFactoryTest.java
index 17a3fb874a4..1bbb544e2cb 100644
--- a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValuePrivacyStorageFactoryTest.java
+++ b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValuePrivacyStorageFactoryTest.java
@@ -185,7 +185,7 @@ private void mockCommonConfiguration(
       final DataStorageFormat dataStorageFormat) {
     when(commonConfiguration.getStoragePath()).thenReturn(tempDatabaseDir);
     when(commonConfiguration.getDataPath()).thenReturn(tempDataDir);
-    when(dataStorageConfiguration.getDatabaseFormat()).thenReturn(dataStorageFormat);
+    when(dataStorageConfiguration.getDataStorageFormat()).thenReturn(dataStorageFormat);
     lenient()
         .when(commonConfiguration.getDataStorageConfiguration())
         .thenReturn(dataStorageConfiguration);
diff --git a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactoryTest.java b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactoryTest.java
index 7148f601cbd..dc3c5fe43f7 100644
--- a/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactoryTest.java
+++ b/plugins/rocksdb/src/test/java/org/hyperledger/besu/plugin/services/storage/rocksdb/RocksDBKeyValueStorageFactoryTest.java
@@ -306,7 +306,7 @@ private void mockCommonConfiguration(
       final Path tempDataDir, final Path tempDatabaseDir, final DataStorageFormat format) {
     when(commonConfiguration.getStoragePath()).thenReturn(tempDatabaseDir);
     when(commonConfiguration.getDataPath()).thenReturn(tempDataDir);
-    lenient().when(dataStorageConfiguration.getDatabaseFormat()).thenReturn(format);
+    lenient().when(dataStorageConfiguration.getDataStorageFormat()).thenReturn(format);
     lenient()
         .when(commonConfiguration.getDataStorageConfiguration())
         .thenReturn(dataStorageConfiguration);