stem based flat db for verkle

besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java

@@ -2756,7 +2756,6 @@ private String generateConfigurationOverview() {
     if (rocksDBPlugin.isHighSpecEnabled()) {
       builder.setHighSpecEnabled();
     }
-
     if (DataStorageFormat.BONSAI.equals(getDataStorageConfiguration().getDataStorageFormat())) {
       final DiffBasedSubStorageConfiguration subStorageConfiguration =
           getDataStorageConfiguration().getDiffBasedSubStorageConfiguration();

besu/src/main/java/org/hyperledger/besu/cli/options/storage/DataStorageOptions.java

@@ -57,6 +57,9 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
   private DiffBasedSubStorageOptions diffBasedSubStorageOptions =
       DiffBasedSubStorageOptions.create();
 
+  /** Options specific to verkle storage modes. */
+  @Mixin private VerkleSubStorageOptions verkleSubStorageOptions = VerkleSubStorageOptions.create();
+
   /** Default Constructor. */
   DataStorageOptions() {}
 
@@ -76,6 +79,7 @@ public static DataStorageOptions create() {
    */
   public void validate(final CommandLine commandLine) {
     diffBasedSubStorageOptions.validate(commandLine, dataStorageFormat);
+    verkleSubStorageOptions.validate(commandLine, dataStorageFormat);
   }
 
   /**
@@ -90,6 +94,8 @@ public static DataStorageOptions fromConfig(final DataStorageConfiguration domai
     dataStorageOptions.receiptCompactionEnabled = domainObject.getReceiptCompactionEnabled();
     dataStorageOptions.diffBasedSubStorageOptions =
         DiffBasedSubStorageOptions.fromConfig(domainObject.getDiffBasedSubStorageConfiguration());
+    dataStorageOptions.verkleSubStorageOptions =
+        VerkleSubStorageOptions.fromConfig(domainObject.getVerkleSubStorageConfiguration());
     return dataStorageOptions;
   }
 
@@ -99,14 +105,16 @@ public DataStorageConfiguration toDomainObject() {
         ImmutableDataStorageConfiguration.builder()
             .dataStorageFormat(dataStorageFormat)
             .receiptCompactionEnabled(receiptCompactionEnabled)
-            .diffBasedSubStorageConfiguration(diffBasedSubStorageOptions.toDomainObject());
+            .diffBasedSubStorageConfiguration(diffBasedSubStorageOptions.toDomainObject())
+            .verkleSubStorageConfiguration(verkleSubStorageOptions.toDomainObject());
     return builder.build();
   }
 
   @Override
   public List<String> getCLIOptions() {
     final List<String> cliOptions = CommandLineUtils.getCLIOptions(this, new DataStorageOptions());
     cliOptions.addAll(diffBasedSubStorageOptions.getCLIOptions());
+    cliOptions.addAll(verkleSubStorageOptions.getCLIOptions());
     return cliOptions;
   }
 

besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java

@@ -137,7 +137,8 @@ public static DiffBasedSubStorageOptions create() {
    *     to apply.
    */
   public void validate(final CommandLine commandLine, final DataStorageFormat dataStorageFormat) {
-    if (DataStorageFormat.BONSAI == dataStorageFormat) {
+    if (DataStorageFormat.BONSAI == dataStorageFormat
+        || DataStorageFormat.VERKLE == dataStorageFormat) {
       if (limitTrieLogsEnabled) {
         if (maxLayersToLoad < MINIMUM_TRIE_LOG_RETENTION_LIMIT) {
           throw new CommandLine.ParameterException(

besu/src/main/java/org/hyperledger/besu/cli/options/storage/VerkleSubStorageOptions.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * 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.cli.options.storage;
+
+import static org.hyperledger.besu.ethereum.worldstate.VerkleSubStorageConfiguration.VerkleUnstable.DEFAULT_STEM_FLAT_DB_ENABLED;
+
+import org.hyperledger.besu.cli.options.CLIOptions;
+import org.hyperledger.besu.cli.util.CommandLineUtils;
+import org.hyperledger.besu.ethereum.worldstate.ImmutableVerkleSubStorageConfiguration;
+import org.hyperledger.besu.ethereum.worldstate.VerkleSubStorageConfiguration;
+import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
+
+import java.util.List;
+
+import picocli.CommandLine;
+import picocli.CommandLine.Option;
+
+/** The Data storage CLI options. */
+public class VerkleSubStorageOptions implements CLIOptions<VerkleSubStorageConfiguration> {
+
+  @CommandLine.ArgGroup(validate = false)
+  private final VerkleSubStorageOptions.Unstable unstableOptions = new Unstable();
+
+  /** Default Constructor. */
+  VerkleSubStorageOptions() {}
+
+  /** The unstable options for data storage. */
+  public static class Unstable {
+
+    @Option(
+        hidden = true,
+        names = {
+          "--Xverkle-stem-flat-db-enabled",
+        },
+        arity = "1",
+        description = "Enables stem flat database strategy for verkle. (default: ${DEFAULT-VALUE})")
+    private Boolean stemFlatDbEnabled = DEFAULT_STEM_FLAT_DB_ENABLED;
+
+    /** Default Constructor. */
+    Unstable() {}
+  }
+
+  /**
+   * Create data storage options.
+   *
+   * @return the data storage options
+   */
+  public static VerkleSubStorageOptions create() {
+    return new VerkleSubStorageOptions();
+  }
+
+  /**
+   * Validates the data storage options
+   *
+   * @param commandLine the full commandLine to check all the options specified by the user
+   * @param dataStorageFormat the selected data storage format which determines the validation rules
+   *     to apply.
+   */
+  public void validate(final CommandLine commandLine, final DataStorageFormat dataStorageFormat) {
+    // no op
+  }
+
+  /**
+   * Converts to options from the configuration
+   *
+   * @param domainObject to be reversed
+   * @return the options that correspond to the configuration
+   */
+  public static VerkleSubStorageOptions fromConfig(
+      final VerkleSubStorageConfiguration domainObject) {
+    final VerkleSubStorageOptions dataStorageOptions = VerkleSubStorageOptions.create();
+    dataStorageOptions.unstableOptions.stemFlatDbEnabled =
+        domainObject.getUnstable().getStemFlatDbEnabled();
+    return dataStorageOptions;
+  }
+
+  @Override
+  public final VerkleSubStorageConfiguration toDomainObject() {
+    return ImmutableVerkleSubStorageConfiguration.builder()
+        .unstable(
+            ImmutableVerkleSubStorageConfiguration.VerkleUnstable.builder()
+                .stemFlatDbEnabled(unstableOptions.stemFlatDbEnabled)
+                .build())
+        .build();
+  }
+
+  @Override
+  public List<String> getCLIOptions() {
+    return CommandLineUtils.getCLIOptions(this, new VerkleSubStorageOptions());
+  }
+}

besu/src/main/java/org/hyperledger/besu/cli/subcommands/storage/TrieLogHelper.java

@@ -26,7 +26,7 @@
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPInput;
 import org.hyperledger.besu.ethereum.rlp.RLP;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog.TrieLogFactoryImpl;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog.BonsaiTrieLogFactoryImpl;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogLayer;
 import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
@@ -386,7 +386,8 @@ IdentityHashMap<byte[], byte[]> readTrieLogsAsRlpFromFile(final String batchFile
       while (!input.isEndOfCurrentList()) {
         final Bytes trieLogBytes = input.currentListAsBytes();
         TrieLogLayer trieLogLayer =
-            TrieLogFactoryImpl.readFrom(new BytesValueRLPInput(Bytes.wrap(trieLogBytes), false));
+            BonsaiTrieLogFactoryImpl.readFrom(
+                new BytesValueRLPInput(Bytes.wrap(trieLogBytes), false));
         trieLogs.put(trieLogLayer.getBlockHash().toArrayUnsafe(), trieLogBytes.toArrayUnsafe());
       }
       input.leaveList();

besu/src/test/java/org/hyperledger/besu/cli/subcommands/storage/TrieLogHelperTest.java

@@ -31,7 +31,7 @@
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
 import org.hyperledger.besu.ethereum.storage.StorageProvider;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
-import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog.TrieLogFactoryImpl;
+import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog.BonsaiTrieLogFactoryImpl;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogLayer;
 import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
 import org.hyperledger.besu.ethereum.worldstate.ImmutableDataStorageConfiguration;
@@ -118,7 +118,7 @@ private static byte[] createTrieLog(final BlockHeader blockHeader) {
     TrieLogLayer trieLogLayer = new TrieLogLayer();
     trieLogLayer.setBlockHash(blockHeader.getBlockHash());
     final BytesValueRLPOutput rlpLog = new BytesValueRLPOutput();
-    TrieLogFactoryImpl.writeTo(trieLogLayer, rlpLog);
+    BonsaiTrieLogFactoryImpl.writeTo(trieLogLayer, rlpLog);
     return rlpLog.encoded().toArrayUnsafe();
   }
 

consensus/merge/src/main/java/org/hyperledger/besu/consensus/merge/blockcreation/MergeCoordinator.java

@@ -564,7 +564,6 @@ public BlockProcessingResult validateBlock(final Block block) {
                 HeaderValidationMode.FULL,
                 HeaderValidationMode.NONE,
                 false);
-
     return validationResult;
   }
 

datatypes/src/main/java/org/hyperledger/besu/datatypes/AccountValue.java

@@ -16,6 +16,8 @@
 
 import org.hyperledger.besu.ethereum.rlp.RLPOutput;
 
+import java.util.Optional;
+
 /** The values of an account in the world state trie. */
 public interface AccountValue {
   /**
@@ -46,6 +48,13 @@ public interface AccountValue {
    */
   Hash getCodeHash();
 
+  /**
+   * The size of the EVM bytecode associated with this account.
+   *
+   * @return the size of the account code (which may be {@link Optional#empty()}).
+   */
+  Optional<Long> getCodeSize();
+
   /**
    * Writes the account value to the provided {@link RLPOutput}.
    *

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/storage/keyvalue/KeyValueStorageProvider.java

@@ -20,6 +20,7 @@
 import org.hyperledger.besu.ethereum.mainnet.ScheduleBasedBlockHeaderFunctions;
 import org.hyperledger.besu.ethereum.storage.StorageProvider;
 import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
+import org.hyperledger.besu.ethereum.trie.diffbased.verkle.cache.preloader.StemPreloader;
 import org.hyperledger.besu.ethereum.trie.diffbased.verkle.storage.VerkleWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
@@ -86,7 +87,8 @@ public WorldStateKeyValueStorage createWorldStateStorage(
     if (dataStorageConfiguration.getDataStorageFormat().equals(DataStorageFormat.BONSAI)) {
       return new BonsaiWorldStateKeyValueStorage(this, metricsSystem, dataStorageConfiguration);
     } else if (dataStorageConfiguration.getDataStorageFormat().equals(DataStorageFormat.VERKLE)) {
-      return new VerkleWorldStateKeyValueStorage(this, metricsSystem);
+      return new VerkleWorldStateKeyValueStorage(
+          this, new StemPreloader(), dataStorageConfiguration, metricsSystem);
     } else {
       return new ForestWorldStateKeyValueStorage(
           getStorageBySegmentIdentifier(KeyValueSegmentIdentifier.WORLD_STATE));

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/common/AbstractStateTrieAccountValue.java

@@ -21,6 +21,8 @@
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.rlp.RLPOutput;
 
+import java.util.Optional;
+
 /** Represents the raw values associated with an account in the world state trie. */
 public abstract class AbstractStateTrieAccountValue implements AccountValue {
 
@@ -76,6 +78,14 @@ public Hash getStorageRoot() {
     return Hash.EMPTY_TRIE_HASH;
   }
 
+  /**
+   * The size of the EVM bytecode associated with this account.
+   *
+   * @return the size of the account code (which may be {@link Optional#empty()}).
+   */
+  @Override
+  public abstract Optional<Long> getCodeSize();
+
   @Override
   public abstract void writeTo(final RLPOutput out);
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/common/GenesisWorldStateProvider.java

@@ -24,6 +24,7 @@
 import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.NoOpTrieLogManager;
 import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldStateConfig;
 import org.hyperledger.besu.ethereum.trie.diffbased.verkle.cache.VerkleNoOpCachedWorldStorageManager;
+import org.hyperledger.besu.ethereum.trie.diffbased.verkle.cache.preloader.StemPreloader;
 import org.hyperledger.besu.ethereum.trie.diffbased.verkle.storage.VerkleWorldStateKeyValueStorage;
 import org.hyperledger.besu.ethereum.trie.diffbased.verkle.worldview.VerkleWorldState;
 import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
@@ -52,7 +53,7 @@ public static MutableWorldState createGenesisWorldState(
       return createGenesisBonsaiWorldState();
     } else if (Objects.requireNonNull(dataStorageConfiguration).getDataStorageFormat()
         == DataStorageFormat.VERKLE) {
-      return createGenesisVerkleWorldState();
+      return createGenesisVerkleWorldState(dataStorageConfiguration);
     } else {
       return createGenesisForestWorldState();
     }
@@ -83,13 +84,16 @@ private static MutableWorldState createGenesisBonsaiWorldState() {
         new DiffBasedWorldStateConfig());
   }
 
-  private static MutableWorldState createGenesisVerkleWorldState() {
+  private static MutableWorldState createGenesisVerkleWorldState(
+      final DataStorageConfiguration dataStorageConfiguration) {
     final VerkleWorldStateKeyValueStorage verkleWorldStateKeyValueStorage =
         new VerkleWorldStateKeyValueStorage(
             new KeyValueStorageProvider(
                 segmentIdentifiers -> new SegmentedInMemoryKeyValueStorage(),
                 new InMemoryKeyValueStorage(),
                 new NoOpMetricsSystem()),
+            new StemPreloader(),
+            dataStorageConfiguration,
             new NoOpMetricsSystem());
     return new VerkleWorldState(
         verkleWorldStateKeyValueStorage,

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/common/PmtStateTrieAccountValue.java

@@ -23,6 +23,7 @@
 import org.hyperledger.besu.ethereum.rlp.RLPOutput;
 
 import java.util.Objects;
+import java.util.Optional;
 
 import org.apache.tuweni.bytes.Bytes32;
 
@@ -49,6 +50,12 @@ public Hash getStorageRoot() {
     return storageRoot;
   }
 
+  @Override
+  public Optional<Long> getCodeSize() {
+    throw new UnsupportedOperationException(
+        "Retrieving code size from state trie account value is not possible with Patricia Merkle Trie");
+  }
+
   @Override
   public boolean equals(final Object o) {
     if (this == o) return true;

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/common/VerkleStateTrieAccountValue.java

@@ -47,6 +47,7 @@ public Hash getStorageRoot() {
    *
    * @return the size of the account code (which may be {@link Optional#empty()}).
    */
+  @Override
   public Optional<Long> getCodeSize() {
     return codeSize;
   }
@@ -70,19 +71,17 @@ public int hashCode() {
   @Override
   public void writeTo(final RLPOutput out) {
     out.startList();
-
-    out.writeUInt256Scalar(balance);
     out.writeLongScalar(nonce);
+    out.writeUInt256Scalar(balance);
     out.writeBytes(codeHash);
     codeSize.ifPresent(out::writeLongScalar);
     out.endList();
   }
 
   public static VerkleStateTrieAccountValue readFrom(final RLPInput in) {
     in.enterList();
-
-    final Wei balance = Wei.of(in.readUInt256Scalar());
     final long nonce = in.readLongScalar();
+    final Wei balance = Wei.of(in.readUInt256Scalar());
     Bytes32 codeHash;
     final Optional<Long> codeSize;
     if (in.nextIsNull()) {