vacp2p/status-linea-besu
1
0
Fork 0
mirror of https://github.com/vacp2p/status-linea-besu.git synced 2026-01-06 20:43:54 -05:00
Code Issues Packages Projects Releases Wiki Activity

rename diffbased bonsai prefix (#8424)

Browse Source 
Signed-off-by: Karim Taam <karim.t2am@gmail.com>
This commit is contained in:
Karim Taam
2025-03-17 15:08:35 +01:00
committed by GitHub
parent 789542f76d
commit 552cb283f9
152 changed files with 948 additions and 945 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/node/ThreadBesuNodeRunner.java
View File

@@ -50,7 +50,7 @@ import org.hyperledger.besu.ethereum.p2p.peers.EnodeURLImpl;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProviderBuilder;
import org.hyperledger.besu.ethereum.transaction.TransactionSimulator;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.evm.internal.EvmConfiguration;

36
besu/src/main/java/org/hyperledger/besu/cli/BesuCommand.java
View File

@@ -68,7 +68,7 @@ import org.hyperledger.besu.cli.options.RpcWebsocketOptions;
import org.hyperledger.besu.cli.options.SynchronizerOptions;
import org.hyperledger.besu.cli.options.TransactionPoolOptions;
import org.hyperledger.besu.cli.options.storage.DataStorageOptions;
import org.hyperledger.besu.cli.options.storage.DiffBasedSubStorageOptions;
import org.hyperledger.besu.cli.options.storage.PathBasedExtraStorageOptions;
import org.hyperledger.besu.cli.options.unstable.QBFTOptions;
import org.hyperledger.besu.cli.presynctasks.PreSynchronizationTaskRunner;
import org.hyperledger.besu.cli.presynctasks.PrivateDatabaseMigrationPreSyncTask;
@@ -134,9 +134,9 @@ import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProviderBuilder;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutablePathBasedExtraStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration;
import org.hyperledger.besu.evm.precompile.AbstractAltBnPrecompiledContract;
import org.hyperledger.besu.evm.precompile.BigIntegerModularExponentiationPrecompiledContract;
import org.hyperledger.besu.evm.precompile.KZGPointEvalPrecompiledContract;
@@ -1652,7 +1652,7 @@ public class BesuCommand implements DefaultCommandValues, Runnable {
"--Xsnapsync-synchronizer-flat option can only be used when --Xbonsai-full-flat-db-enabled is true",
dataStorageOptions
.toDomainObject()
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getFullFlatDbEnabled(),
asList(
@@ -1805,8 +1805,8 @@ public class BesuCommand implements DefaultCommandValues, Runnable {
.apiConfiguration(apiConfigurationSupplier.get())
.besuComponent(besuComponent);
if (DataStorageFormat.BONSAI.equals(getDataStorageConfiguration().getDataStorageFormat())) {
final DiffBasedSubStorageConfiguration subStorageConfiguration =
getDataStorageConfiguration().getDiffBasedSubStorageConfiguration();
final PathBasedExtraStorageConfiguration subStorageConfiguration =
getDataStorageConfiguration().getPathBasedExtraStorageConfiguration();
besuControllerBuilder.isParallelTxProcessingEnabled(
subStorageConfiguration.getUnstable().isParallelTxProcessingEnabled());
}
@@ -2144,30 +2144,30 @@ public class BesuCommand implements DefaultCommandValues, Runnable {
if (SyncMode.FULL.equals(getDefaultSyncModeIfNotSet())
&& DataStorageFormat.BONSAI.equals(dataStorageConfiguration.getDataStorageFormat())) {
final DiffBasedSubStorageConfiguration diffBasedSubStorageConfiguration =
dataStorageConfiguration.getDiffBasedSubStorageConfiguration();
if (diffBasedSubStorageConfiguration.getLimitTrieLogsEnabled()) {
final PathBasedExtraStorageConfiguration pathBasedExtraStorageConfiguration =
dataStorageConfiguration.getPathBasedExtraStorageConfiguration();
if (pathBasedExtraStorageConfiguration.getLimitTrieLogsEnabled()) {
if (CommandLineUtils.isOptionSet(
commandLine, DiffBasedSubStorageOptions.LIMIT_TRIE_LOGS_ENABLED)) {
commandLine, PathBasedExtraStorageOptions.LIMIT_TRIE_LOGS_ENABLED)) {
throw new ParameterException(
commandLine,
String.format(
"Cannot enable %s with --sync-mode=%s and --data-storage-format=%s. You must set %s or use a different sync-mode",
DiffBasedSubStorageOptions.LIMIT_TRIE_LOGS_ENABLED,
PathBasedExtraStorageOptions.LIMIT_TRIE_LOGS_ENABLED,
SyncMode.FULL,
DataStorageFormat.BONSAI,
DiffBasedSubStorageOptions.LIMIT_TRIE_LOGS_ENABLED + "=false"));
PathBasedExtraStorageOptions.LIMIT_TRIE_LOGS_ENABLED + "=false"));
}
dataStorageConfiguration =
ImmutableDataStorageConfiguration.copyOf(dataStorageConfiguration)
.withDiffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.copyOf(
dataStorageConfiguration.getDiffBasedSubStorageConfiguration())
.withPathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.copyOf(
dataStorageConfiguration.getPathBasedExtraStorageConfiguration())
.withLimitTrieLogsEnabled(false));
logger.warn(
"Forcing {}, since it cannot be enabled with --sync-mode={} and --data-storage-format={}.",
DiffBasedSubStorageOptions.LIMIT_TRIE_LOGS_ENABLED + "=false",
PathBasedExtraStorageOptions.LIMIT_TRIE_LOGS_ENABLED + "=false",
SyncMode.FULL,
DataStorageFormat.BONSAI);
}
@@ -2734,8 +2734,8 @@ public class BesuCommand implements DefaultCommandValues, Runnable {
}
if (DataStorageFormat.BONSAI.equals(getDataStorageConfiguration().getDataStorageFormat())) {
final DiffBasedSubStorageConfiguration subStorageConfiguration =
getDataStorageConfiguration().getDiffBasedSubStorageConfiguration();
final PathBasedExtraStorageConfiguration subStorageConfiguration =
getDataStorageConfiguration().getPathBasedExtraStorageConfiguration();
if (subStorageConfiguration.getLimitTrieLogsEnabled()) {
builder.setLimitTrieLogsEnabled();
builder.setTrieLogRetentionLimit(subStorageConfiguration.getMaxLayersToLoad());

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

@@ -50,12 +50,12 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
private Boolean receiptCompactionEnabled = DEFAULT_RECEIPT_COMPACTION_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.
* Options specific to path-based storage modes. Holds the necessary parameters to configure
* path-based storage, such as the Bonsai mode or Verkle in the future.
*/
@Mixin
private DiffBasedSubStorageOptions diffBasedSubStorageOptions =
DiffBasedSubStorageOptions.create();
private PathBasedExtraStorageOptions pathBasedExtraStorageOptions =
PathBasedExtraStorageOptions.create();
/** Default Constructor. */
DataStorageOptions() {}
@@ -75,7 +75,7 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
* @param commandLine the full commandLine to check all the options specified by the user
*/
public void validate(final CommandLine commandLine) {
diffBasedSubStorageOptions.validate(commandLine, dataStorageFormat);
pathBasedExtraStorageOptions.validate(commandLine, dataStorageFormat);
}
/**
@@ -88,8 +88,9 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
final DataStorageOptions dataStorageOptions = DataStorageOptions.create();
dataStorageOptions.dataStorageFormat = domainObject.getDataStorageFormat();
dataStorageOptions.receiptCompactionEnabled = domainObject.getReceiptCompactionEnabled();
dataStorageOptions.diffBasedSubStorageOptions =
DiffBasedSubStorageOptions.fromConfig(domainObject.getDiffBasedSubStorageConfiguration());
dataStorageOptions.pathBasedExtraStorageOptions =
PathBasedExtraStorageOptions.fromConfig(
domainObject.getPathBasedExtraStorageConfiguration());
return dataStorageOptions;
}
@@ -99,14 +100,14 @@ public class DataStorageOptions implements CLIOptions<DataStorageConfiguration>
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(dataStorageFormat)
.receiptCompactionEnabled(receiptCompactionEnabled)
.diffBasedSubStorageConfiguration(diffBasedSubStorageOptions.toDomainObject());
.pathBasedExtraStorageConfiguration(pathBasedExtraStorageOptions.toDomainObject());
return builder.build();
}
@Override
public List<String> getCLIOptions() {
final List<String> cliOptions = CommandLineUtils.getCLIOptions(this, new DataStorageOptions());
cliOptions.addAll(diffBasedSubStorageOptions.getCLIOptions());
cliOptions.addAll(pathBasedExtraStorageOptions.getCLIOptions());
return cliOptions;
}

43
besu/src/main/java/org/hyperledger/besu/cli/options/storage/DiffBasedSubStorageOptions.java → besu/src/main/java/org/hyperledger/besu/cli/options/storage/PathBasedExtraStorageOptions.java
View File

@@ -14,17 +14,17 @@
*/
package org.hyperledger.besu.cli.options.storage;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DEFAULT_LIMIT_TRIE_LOGS_ENABLED;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DEFAULT_MAX_LAYERS_TO_LOAD;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DiffBasedUnstable.DEFAULT_CODE_USING_CODE_HASH_ENABLED;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DiffBasedUnstable.DEFAULT_FULL_FLAT_DB_ENABLED;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.DEFAULT_LIMIT_TRIE_LOGS_ENABLED;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.DEFAULT_MAX_LAYERS_TO_LOAD;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.PathBasedUnstable.DEFAULT_CODE_USING_CODE_HASH_ENABLED;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.PathBasedUnstable.DEFAULT_FULL_FLAT_DB_ENABLED;
import org.hyperledger.besu.cli.options.CLIOptions;
import org.hyperledger.besu.cli.util.CommandLineUtils;
import org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutablePathBasedExtraStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
import java.util.List;
@@ -33,7 +33,8 @@ import picocli.CommandLine;
import picocli.CommandLine.Option;
/** The Data storage CLI options. */
public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorageConfiguration> {
public class PathBasedExtraStorageOptions
implements CLIOptions<PathBasedExtraStorageConfiguration> {
/** The maximum number of historical layers to load. */
public static final String MAX_LAYERS_TO_LOAD = "--bonsai-historical-block-limit";
@@ -80,10 +81,10 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
private Integer trieLogPruningWindowSize = DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
@CommandLine.ArgGroup(validate = false)
private final DiffBasedSubStorageOptions.Unstable unstableOptions = new Unstable();
private final PathBasedExtraStorageOptions.Unstable unstableOptions = new Unstable();
/** Default Constructor. */
DiffBasedSubStorageOptions() {}
PathBasedExtraStorageOptions() {}
/** The unstable options for data storage. */
public static class Unstable {
@@ -125,8 +126,8 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
*
* @return the data storage options
*/
public static DiffBasedSubStorageOptions create() {
return new DiffBasedSubStorageOptions();
public static PathBasedExtraStorageOptions create() {
return new PathBasedExtraStorageOptions();
}
/**
@@ -168,7 +169,7 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
if (unstableOptions.isParallelTxProcessingEnabled) {
throw new CommandLine.ParameterException(
commandLine,
"Transaction parallelization is not supported unless operating in a 'diffbased' mode, such as Bonsai.");
"Transaction parallelization is not supported unless operating in a 'pathbased' mode, such as Bonsai.");
}
}
}
@@ -179,9 +180,9 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
* @param domainObject to be reversed
* @return the options that correspond to the configuration
*/
public static DiffBasedSubStorageOptions fromConfig(
final DiffBasedSubStorageConfiguration domainObject) {
final DiffBasedSubStorageOptions dataStorageOptions = DiffBasedSubStorageOptions.create();
public static PathBasedExtraStorageOptions fromConfig(
final PathBasedExtraStorageConfiguration domainObject) {
final PathBasedExtraStorageOptions dataStorageOptions = PathBasedExtraStorageOptions.create();
dataStorageOptions.maxLayersToLoad = domainObject.getMaxLayersToLoad();
dataStorageOptions.limitTrieLogsEnabled = domainObject.getLimitTrieLogsEnabled();
dataStorageOptions.trieLogPruningWindowSize = domainObject.getTrieLogPruningWindowSize();
@@ -196,13 +197,13 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
}
@Override
public final DiffBasedSubStorageConfiguration toDomainObject() {
return ImmutableDiffBasedSubStorageConfiguration.builder()
public final PathBasedExtraStorageConfiguration toDomainObject() {
return ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(maxLayersToLoad)
.limitTrieLogsEnabled(limitTrieLogsEnabled)
.trieLogPruningWindowSize(trieLogPruningWindowSize)
.unstable(
ImmutableDiffBasedSubStorageConfiguration.DiffBasedUnstable.builder()
ImmutablePathBasedExtraStorageConfiguration.PathBasedUnstable.builder()
.fullFlatDbEnabled(unstableOptions.fullFlatDbEnabled)
.codeStoredByCodeHashEnabled(unstableOptions.codeUsingCodeHashEnabled)
.isParallelTxProcessingEnabled(unstableOptions.isParallelTxProcessingEnabled)
@@ -212,6 +213,6 @@ public class DiffBasedSubStorageOptions implements CLIOptions<DiffBasedSubStorag
@Override
public List<String> getCLIOptions() {
return CommandLineUtils.getCLIOptions(this, new DiffBasedSubStorageOptions());
return CommandLineUtils.getCLIOptions(this, new PathBasedExtraStorageOptions());
}
}

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

@@ -15,10 +15,10 @@
package org.hyperledger.besu.cli.subcommands.storage;
import static com.google.common.base.Preconditions.checkArgument;
import static org.hyperledger.besu.cli.options.storage.DiffBasedSubStorageOptions.MAX_LAYERS_TO_LOAD;
import static org.hyperledger.besu.cli.options.storage.DiffBasedSubStorageOptions.TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.cli.options.storage.PathBasedExtraStorageOptions.MAX_LAYERS_TO_LOAD;
import static org.hyperledger.besu.cli.options.storage.PathBasedExtraStorageOptions.TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.controller.BesuController.DATABASE_PATH;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;
@@ -26,11 +26,11 @@ import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
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.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogLayer;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.trielog.TrieLogFactoryImpl;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogLayer;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration;
import java.io.File;
import java.io.FileInputStream;
@@ -65,7 +65,7 @@ public class TrieLogHelper {
boolean prune(
final DataStorageConfiguration config,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final MutableBlockchain blockchain,
final Path dataDirectoryPath) {
@@ -74,7 +74,7 @@ public class TrieLogHelper {
validatePruneConfiguration(config);
final long layersToRetain = config.getDiffBasedSubStorageConfiguration().getMaxLayersToLoad();
final long layersToRetain = config.getPathBasedExtraStorageConfiguration().getMaxLayersToLoad();
final long chainHeight = blockchain.getChainHeadBlockNumber();
@@ -121,7 +121,7 @@ public class TrieLogHelper {
}
private void processTrieLogBatches(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final MutableBlockchain blockchain,
final long chainHeight,
final long lastBlockNumberToRetainTrieLogsFor,
@@ -150,7 +150,7 @@ public class TrieLogHelper {
private void saveTrieLogBatches(
final String batchFileName,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final List<Hash> trieLogKeys) {
try {
@@ -162,7 +162,7 @@ public class TrieLogHelper {
}
private void restoreTrieLogBatches(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final long batchNumber,
final String batchFileNameBase) {
@@ -215,7 +215,7 @@ public class TrieLogHelper {
final MutableBlockchain blockchain,
final long chainHeight,
final long lastBlockNumberToRetainTrieLogsFor,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final long layersToRetain) {
if (lastBlockNumberToRetainTrieLogsFor < 0) {
@@ -255,7 +255,7 @@ public class TrieLogHelper {
}
private void recreateTrieLogs(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final long batchNumber,
final String batchFileNameBase)
throws IOException {
@@ -275,7 +275,7 @@ public class TrieLogHelper {
final int chunkSize,
final List<byte[]> keys,
final IdentityHashMap<byte[], byte[]> trieLogsToRetain,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage) {
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage) {
var updater = rootWorldStateStorage.updater();
int endIndex = Math.min(startIndex + chunkSize, keys.size());
@@ -292,14 +292,14 @@ public class TrieLogHelper {
@VisibleForTesting
void validatePruneConfiguration(final DataStorageConfiguration config) {
final DiffBasedSubStorageConfiguration subStorageConfiguration =
config.getDiffBasedSubStorageConfiguration();
final PathBasedExtraStorageConfiguration subStorageConfiguration =
config.getPathBasedExtraStorageConfiguration();
checkArgument(
subStorageConfiguration.getMaxLayersToLoad()
>= DiffBasedSubStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT,
>= PathBasedExtraStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT,
String.format(
MAX_LAYERS_TO_LOAD + " minimum value is %d",
DiffBasedSubStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT));
PathBasedExtraStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT));
checkArgument(
subStorageConfiguration.getTrieLogPruningWindowSize() > 0,
String.format(
@@ -316,7 +316,7 @@ public class TrieLogHelper {
private void saveTrieLogsInFile(
final List<Hash> trieLogsKeys,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final String batchFileName)
throws IOException {
@@ -353,7 +353,7 @@ public class TrieLogHelper {
private void saveTrieLogsAsRlpInFile(
final List<Hash> trieLogsKeys,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final String batchFileName) {
File file = new File(batchFileName);
if (file.exists()) {
@@ -399,7 +399,7 @@ public class TrieLogHelper {
private IdentityHashMap<byte[], byte[]> getTrieLogs(
final List<Hash> trieLogKeys,
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage) {
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage) {
IdentityHashMap<byte[], byte[]> trieLogsToRetain = new IdentityHashMap<>();
LOG.info("Obtaining trielogs from db, this may take a few minutes...");
@@ -412,7 +412,7 @@ public class TrieLogHelper {
}
TrieLogCount getCount(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final int limit,
final Blockchain blockchain) {
final AtomicInteger total = new AtomicInteger();
@@ -453,7 +453,7 @@ public class TrieLogHelper {
}
void importTrieLog(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage, final Path trieLogFilePath) {
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage, final Path trieLogFilePath) {
var trieLog = readTrieLogsAsRlpFromFile(trieLogFilePath.toString());
@@ -463,7 +463,7 @@ public class TrieLogHelper {
}
void exportTrieLog(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final List<Hash> trieLogHash,
final Path directoryPath)
throws IOException {

12
besu/src/main/java/org/hyperledger/besu/cli/subcommands/storage/TrieLogSubCommand.java
View File

@@ -25,11 +25,11 @@ import org.hyperledger.besu.controller.BesuController;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
import org.hyperledger.besu.ethereum.storage.StorageProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogPruner;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogPruner;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutablePathBasedExtraStorageConfiguration;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
import java.io.IOException;
@@ -91,9 +91,9 @@ public class TrieLogSubCommand implements Runnable {
.setupControllerBuilder()
.dataStorageConfiguration(
ImmutableDataStorageConfiguration.copyOf(config)
.withDiffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.copyOf(
config.getDiffBasedSubStorageConfiguration())
.withPathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.copyOf(
config.getPathBasedExtraStorageConfiguration())
.withLimitTrieLogsEnabled(false)))
.build();
}

4
besu/src/main/java/org/hyperledger/besu/components/BesuComponent.java
View File

@@ -17,8 +17,8 @@ package org.hyperledger.besu.components;
import org.hyperledger.besu.cli.BesuCommand;
import org.hyperledger.besu.ethereum.eth.transactions.BlobCache;
import org.hyperledger.besu.ethereum.eth.transactions.BlobCacheModule;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.metrics.MetricsSystemModule;
import org.hyperledger.besu.plugin.services.MetricsSystem;
import org.hyperledger.besu.services.BesuPluginContextImpl;

22
besu/src/main/java/org/hyperledger/besu/controller/BesuControllerBuilder.java
View File

@@ -85,14 +85,14 @@ import org.hyperledger.besu.ethereum.p2p.config.SubProtocolConfiguration;
import org.hyperledger.besu.ethereum.storage.StorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier;
import org.hyperledger.besu.ethereum.transaction.TransactionSimulator;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogPruner;
import org.hyperledger.besu.ethereum.trie.forest.ForestWorldStateArchive;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogPruner;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive.WorldStateHealer;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
@@ -786,8 +786,8 @@ public abstract class BesuControllerBuilder implements MiningParameterOverrides
protocolContext, protocolSchedule, miningConfiguration);
if (DataStorageFormat.BONSAI.equals(dataStorageConfiguration.getDataStorageFormat())) {
final DiffBasedSubStorageConfiguration subStorageConfiguration =
dataStorageConfiguration.getDiffBasedSubStorageConfiguration();
final PathBasedExtraStorageConfiguration subStorageConfiguration =
dataStorageConfiguration.getPathBasedExtraStorageConfiguration();
if (subStorageConfiguration.getLimitTrieLogsEnabled()) {
final TrieLogManager trieLogManager =
((BonsaiWorldStateProvider) worldStateArchive).getTrieLogManager();
@@ -850,8 +850,8 @@ public abstract class BesuControllerBuilder implements MiningParameterOverrides
final Blockchain blockchain,
final EthScheduler scheduler) {
final boolean isProofOfStake = genesisConfigOptions.getTerminalTotalDifficulty().isPresent();
final DiffBasedSubStorageConfiguration subStorageConfiguration =
dataStorageConfiguration.getDiffBasedSubStorageConfiguration();
final PathBasedExtraStorageConfiguration subStorageConfiguration =
dataStorageConfiguration.getPathBasedExtraStorageConfiguration();
final TrieLogPruner trieLogPruner =
new TrieLogPruner(
(BonsaiWorldStateKeyValueStorage) worldStateStorage,
@@ -1140,7 +1140,7 @@ public abstract class BesuControllerBuilder implements MiningParameterOverrides
blockchain,
Optional.of(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getMaxLayersToLoad()),
bonsaiCachedMerkleTrieLoader,
besuComponent.map(BesuComponent::getBesuPluginContext).orElse(null),

2
besu/src/main/java/org/hyperledger/besu/services/BlockSimulatorServiceImpl.java
View File

@@ -27,7 +27,7 @@ import org.hyperledger.besu.ethereum.transaction.BlockSimulator;
import org.hyperledger.besu.ethereum.transaction.BlockStateCall;
import org.hyperledger.besu.ethereum.transaction.CallParameter;
import org.hyperledger.besu.ethereum.transaction.TransactionSimulator;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.plugin.Unstable;
import org.hyperledger.besu.plugin.data.BlockOverrides;

18
besu/src/main/java/org/hyperledger/besu/services/SynchronizationServiceImpl.java
View File

@@ -14,7 +14,7 @@
*/
package org.hyperledger.besu.services;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import org.hyperledger.besu.consensus.merge.MergeContext;
import org.hyperledger.besu.datatypes.Hash;
@@ -26,9 +26,9 @@ import org.hyperledger.besu.ethereum.core.Synchronizer;
import org.hyperledger.besu.ethereum.eth.sync.state.SyncState;
import org.hyperledger.besu.ethereum.mainnet.HeaderValidationMode;
import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.plugin.data.BlockBody;
import org.hyperledger.besu.plugin.data.BlockHeader;
@@ -51,7 +51,7 @@ public class SynchronizationServiceImpl implements SynchronizationService {
private final Synchronizer synchronizer;
private final SyncState syncState;
private final Optional<DiffBasedWorldStateProvider> worldStateArchive;
private final Optional<PathBasedWorldStateProvider> worldStateArchive;
/**
* Constructor for SynchronizationServiceImpl.
@@ -74,8 +74,8 @@ public class SynchronizationServiceImpl implements SynchronizationService {
this.syncState = syncState;
this.worldStateArchive =
Optional.ofNullable(worldStateArchive)
.filter(z -> z instanceof DiffBasedWorldStateProvider)
.map(DiffBasedWorldStateProvider.class::cast);
.filter(z -> z instanceof PathBasedWorldStateProvider)
.map(PathBasedWorldStateProvider.class::cast);
}
@Override
@@ -147,14 +147,14 @@ public class SynchronizationServiceImpl implements SynchronizationService {
worldStateArchive.ifPresent(
archive -> {
archive.getWorldStateSharedSpec().setTrieDisabled(true);
final DiffBasedWorldStateKeyValueStorage worldStateStorage =
final PathBasedWorldStateKeyValueStorage worldStateStorage =
archive.getWorldStateKeyValueStorage();
final Optional<Hash> worldStateBlockHash = worldStateStorage.getWorldStateBlockHash();
final Optional<Bytes> worldStateRootHash = worldStateStorage.getWorldStateRootHash();
if (worldStateRootHash.isPresent() && worldStateBlockHash.isPresent()) {
worldStateStorage.clearTrie();
// keep root and block hash in the trie branch
final DiffBasedWorldStateKeyValueStorage.Updater updater = worldStateStorage.updater();
final PathBasedWorldStateKeyValueStorage.Updater updater = worldStateStorage.updater();
updater.saveWorldState(
worldStateBlockHash.get(), Bytes32.wrap(worldStateRootHash.get()), Bytes.EMPTY);
updater.commit();

2
besu/src/test/java/org/hyperledger/besu/FlexGroupPrivacyTest.java
View File

@@ -40,7 +40,7 @@ import org.hyperledger.besu.ethereum.eth.transactions.BlobCacheModule;
import org.hyperledger.besu.ethereum.eth.transactions.TransactionPoolConfiguration;
import org.hyperledger.besu.ethereum.p2p.config.NetworkingConfiguration;
import org.hyperledger.besu.ethereum.privacy.storage.PrivacyStorageProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.evm.precompile.PrecompiledContract;

2
besu/src/test/java/org/hyperledger/besu/PrivacyReorgTest.java
View File

@@ -64,7 +64,7 @@ import org.hyperledger.besu.ethereum.privacy.storage.PrivacyGroupHeadBlockMap;
import org.hyperledger.besu.ethereum.privacy.storage.PrivacyStorageProvider;
import org.hyperledger.besu.ethereum.privacy.storage.PrivateStateStorage;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.evm.log.LogsBloomFilter;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;

2
besu/src/test/java/org/hyperledger/besu/PrivacyTest.java
View File

@@ -39,7 +39,7 @@ import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
import org.hyperledger.besu.ethereum.eth.transactions.BlobCacheModule;
import org.hyperledger.besu.ethereum.eth.transactions.TransactionPoolConfiguration;
import org.hyperledger.besu.ethereum.p2p.config.NetworkingConfiguration;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoaderModule;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.evm.precompile.PrecompiledContract;

2
besu/src/test/java/org/hyperledger/besu/chainimport/JsonBlockImporterTest.java
View File

@@ -44,7 +44,7 @@ import org.hyperledger.besu.ethereum.eth.sync.SynchronizerConfiguration;
import org.hyperledger.besu.ethereum.eth.transactions.BlobCacheModule;
import org.hyperledger.besu.ethereum.eth.transactions.TransactionPoolConfiguration;
import org.hyperledger.besu.ethereum.p2p.config.NetworkingConfiguration;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.metrics.MetricsSystemModule;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;

13
besu/src/test/java/org/hyperledger/besu/cli/BesuCommandTest.java
View File

@@ -1282,7 +1282,7 @@ public class BesuCommandTest extends CommandTestAbstract {
}
@Test
public void diffbasedLimitTrieLogsEnabledByDefault() {
public void pathbasedLimitTrieLogsEnabledByDefault() {
parseCommand();
verify(mockControllerBuilder)
.dataStorageConfiguration(dataStorageConfigurationArgumentCaptor.capture());
@@ -1292,7 +1292,7 @@ public class BesuCommandTest extends CommandTestAbstract {
assertThat(dataStorageConfiguration.getDataStorageFormat()).isEqualTo(BONSAI);
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getLimitTrieLogsEnabled())
.isTrue();
assertThat(commandOutput.toString(UTF_8)).isEmpty();
@@ -1311,7 +1311,7 @@ public class BesuCommandTest extends CommandTestAbstract {
assertThat(dataStorageConfiguration.getDataStorageFormat()).isEqualTo(BONSAI);
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getLimitTrieLogsEnabled())
.isFalse();
verify(mockLogger)
@@ -1348,7 +1348,8 @@ public class BesuCommandTest extends CommandTestAbstract {
final DataStorageConfiguration dataStorageConfiguration =
dataStorageConfigurationArgumentCaptor.getValue();
assertThat(dataStorageConfiguration.getDataStorageFormat()).isEqualTo(BONSAI);
assertThat(dataStorageConfiguration.getDiffBasedSubStorageConfiguration().getMaxLayersToLoad())
assertThat(
dataStorageConfiguration.getPathBasedExtraStorageConfiguration().getMaxLayersToLoad())
.isEqualTo(11);
assertThat(commandOutput.toString(UTF_8)).isEmpty();
assertThat(commandErrorOutput.toString(UTF_8)).isEmpty();
@@ -2525,7 +2526,7 @@ public class BesuCommandTest extends CommandTestAbstract {
besuCommand
.getDataStorageOptions()
.toDomainObject()
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getFullFlatDbEnabled())
.isTrue();
@@ -2538,7 +2539,7 @@ public class BesuCommandTest extends CommandTestAbstract {
besuCommand
.dataStorageOptions
.toDomainObject()
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getFullFlatDbEnabled())
.isFalse();

2
besu/src/test/java/org/hyperledger/besu/cli/ConfigurationOverviewBuilderTest.java
View File

@@ -162,7 +162,7 @@ class ConfigurationOverviewBuilderTest {
}
@Test
void setDiffbasedLimitTrieLogsEnabled() {
void setPathBasedLimitTrieLogsEnabled() {
final String noTrieLogRetentionLimitSet = builder.build();
assertThat(noTrieLogRetentionLimitSet).doesNotContain("Limit trie logs enabled");

30
besu/src/test/java/org/hyperledger/besu/cli/options/stable/DataStorageOptionsTest.java
View File

@@ -15,13 +15,13 @@
package org.hyperledger.besu.cli.options.stable;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.MINIMUM_TRIE_LOG_RETENTION_LIMIT;
import org.hyperledger.besu.cli.options.AbstractCLIOptionsTest;
import org.hyperledger.besu.cli.options.storage.DataStorageOptions;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutablePathBasedExtraStorageConfiguration;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
import org.junit.jupiter.api.Test;
@@ -35,7 +35,7 @@ public class DataStorageOptionsTest
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getTrieLogPruningWindowSize())
.isEqualTo(600),
"--bonsai-limit-trie-logs-enabled",
@@ -49,7 +49,7 @@ public class DataStorageOptionsTest
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getTrieLogPruningWindowSize())
.isEqualTo(600),
"--Xbonsai-limit-trie-logs-enabled",
@@ -63,14 +63,14 @@ public class DataStorageOptionsTest
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getLimitTrieLogsEnabled())
.isEqualTo(false),
"--bonsai-limit-trie-logs-enabled=false");
}
@Test
public void diffbasedTrieLogPruningWindowSizeShouldBePositive() {
public void pathbasedTrieLogPruningWindowSizeShouldBePositive() {
internalTestFailure(
"--bonsai-trie-logs-pruning-window-size=0 must be greater than 0",
"--bonsai-limit-trie-logs-enabled",
@@ -79,7 +79,7 @@ public class DataStorageOptionsTest
}
@Test
public void diffbasedTrieLogPruningWindowSizeShouldBeAboveRetentionLimit() {
public void pathbasedTrieLogPruningWindowSizeShouldBeAboveRetentionLimit() {
internalTestFailure(
"--bonsai-trie-logs-pruning-window-size=512 must be greater than --bonsai-historical-block-limit=512",
"--bonsai-limit-trie-logs-enabled",
@@ -93,7 +93,7 @@ public class DataStorageOptionsTest
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getMaxLayersToLoad())
.isEqualTo(MINIMUM_TRIE_LOG_RETENTION_LIMIT + 1),
"--bonsai-limit-trie-logs-enabled",
@@ -107,7 +107,7 @@ public class DataStorageOptionsTest
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getMaxLayersToLoad())
.isEqualTo(MINIMUM_TRIE_LOG_RETENTION_LIMIT),
"--bonsai-limit-trie-logs-enabled",
@@ -125,12 +125,12 @@ public class DataStorageOptionsTest
}
@Test
public void diffbasedCodeUsingCodeHashEnabledCanBeEnabled() {
public void pathbasedCodeUsingCodeHashEnabledCanBeEnabled() {
internalTestSuccess(
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getCodeStoredByCodeHashEnabled())
.isEqualTo(true),
@@ -139,12 +139,12 @@ public class DataStorageOptionsTest
}
@Test
public void diffbasedCodeUsingCodeHashEnabledCanBeDisabled() {
public void pathbasedCodeUsingCodeHashEnabledCanBeDisabled() {
internalTestSuccess(
dataStorageConfiguration ->
assertThat(
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getCodeStoredByCodeHashEnabled())
.isEqualTo(false),
@@ -185,8 +185,8 @@ public class DataStorageOptionsTest
protected DataStorageConfiguration createCustomizedDomainObject() {
return ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(DataStorageFormat.BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(513L)
.limitTrieLogsEnabled(true)
.trieLogPruningWindowSize(514)

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

@@ -17,7 +17,7 @@ package org.hyperledger.besu.cli.subcommands.storage;
import static java.util.Collections.singletonList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.DEFAULT_TRIE_LOG_PRUNING_WINDOW_SIZE;
import static org.hyperledger.besu.plugin.services.storage.DataStorageFormat.BONSAI;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.spy;
@@ -30,12 +30,12 @@ import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
import org.hyperledger.besu.ethereum.core.InMemoryKeyValueStorageProvider;
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.common.trielog.TrieLogLayer;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.trielog.TrieLogFactoryImpl;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogLayer;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutableDiffBasedSubStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.ImmutablePathBasedExtraStorageConfiguration;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;
import java.io.FileNotFoundException;
@@ -135,8 +135,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(3L)
.limitTrieLogsEnabled(true)
.build())
@@ -176,8 +176,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(2L)
.limitTrieLogsEnabled(true)
.build())
@@ -199,8 +199,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(10L)
.limitTrieLogsEnabled(true)
.build())
@@ -222,8 +222,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(2L)
.limitTrieLogsEnabled(true)
.build())
@@ -246,8 +246,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(6L)
.limitTrieLogsEnabled(true)
.build())
@@ -271,8 +271,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(3L)
.limitTrieLogsEnabled(true)
.build())
@@ -303,8 +303,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(511L)
.limitTrieLogsEnabled(true)
.build())
@@ -324,8 +324,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(512L)
.limitTrieLogsEnabled(true)
.trieLogPruningWindowSize(0)
@@ -345,8 +345,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(512L)
.limitTrieLogsEnabled(true)
.trieLogPruningWindowSize(512)
@@ -368,8 +368,8 @@ class TrieLogHelperTest {
DataStorageConfiguration dataStorageConfiguration =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.maxLayersToLoad(3L)
.limitTrieLogsEnabled(true)
.build())

6
besu/src/test/java/org/hyperledger/besu/cli/subcommands/storage/TrieLogSubCommandTest.java
View File

@@ -58,9 +58,9 @@ class TrieLogSubCommandTest extends CommandTestAbstract {
.dataStorageConfiguration(dataStorageConfigurationArgumentCaptor.capture());
final List<DataStorageConfiguration> configs =
dataStorageConfigurationArgumentCaptor.getAllValues();
assertThat(configs.get(0).getDiffBasedSubStorageConfiguration().getLimitTrieLogsEnabled())
assertThat(configs.get(0).getPathBasedExtraStorageConfiguration().getLimitTrieLogsEnabled())
.isTrue();
assertThat(configs.get(1).getDiffBasedSubStorageConfiguration().getLimitTrieLogsEnabled())
assertThat(configs.get(1).getPathBasedExtraStorageConfiguration().getLimitTrieLogsEnabled())
.isFalse();
}
@@ -75,7 +75,7 @@ class TrieLogSubCommandTest extends CommandTestAbstract {
.allMatch(
dataStorageConfiguration ->
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getLimitTrieLogsEnabled());
}
}

2
besu/src/test/java/org/hyperledger/besu/services/BesuEventsImplTest.java
View File

@@ -58,7 +58,7 @@ import org.hyperledger.besu.ethereum.mainnet.ValidationResult;
import org.hyperledger.besu.ethereum.mainnet.feemarket.FeeMarket;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStoragePrefixedKeyBlockchainStorage;
import org.hyperledger.besu.ethereum.storage.keyvalue.VariablesKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;
import org.hyperledger.besu.plugin.data.AddedBlockContext;

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

@@ -16,7 +16,7 @@ package org.hyperledger.besu.consensus.merge.blockcreation;
import static java.util.stream.Collectors.joining;
import static org.hyperledger.besu.consensus.merge.blockcreation.MergeMiningCoordinator.ForkchoiceResult.Status.INVALID;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import org.hyperledger.besu.consensus.merge.MergeContext;
import org.hyperledger.besu.consensus.merge.PayloadWrapper;

2
ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/internal/pojoadapter/AccountAdapter.java
View File

@@ -17,7 +17,7 @@ package org.hyperledger.besu.ethereum.api.graphql.internal.pojoadapter;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.api.query.BlockchainQueries;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.evm.account.Account;
import org.hyperledger.besu.evm.account.AccountState;

14
ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/DebugSetHead.java
View File

@@ -15,7 +15,7 @@
package org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods;
import static org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType.UNKNOWN_BLOCK;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.ProtocolContext;
@@ -30,7 +30,7 @@ import org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType;
import org.hyperledger.besu.ethereum.api.query.BlockchainQueries;
import org.hyperledger.besu.ethereum.chain.MutableBlockchain;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import java.util.Optional;
@@ -90,9 +90,9 @@ public class DebugSetHead extends AbstractBlockParameterOrBlockHashMethod {
if (maybeMoveWorldstate.orElse(Boolean.FALSE)) {
var archive = blockchainQueries.getWorldStateArchive();
// Only DiffBasedWorldState's need to be moved:
if (archive instanceof DiffBasedWorldStateProvider diffBasedArchive) {
if (rollIncrementally(maybeBlockHeader.get(), blockchain, diffBasedArchive)) {
// Only PathBasedWorldState's need to be moved:
if (archive instanceof PathBasedWorldStateProvider pathBasedArchive) {
if (rollIncrementally(maybeBlockHeader.get(), blockchain, pathBasedArchive)) {
return JsonRpcSuccessResponse.SUCCESS_RESULT;
}
}
@@ -108,11 +108,11 @@ public class DebugSetHead extends AbstractBlockParameterOrBlockHashMethod {
private boolean rollIncrementally(
final BlockHeader target,
final MutableBlockchain blockchain,
final DiffBasedWorldStateProvider archive) {
final PathBasedWorldStateProvider archive) {
try {
if (archive.isWorldStateAvailable(target.getStateRoot(), target.getBlockHash())) {
// WARNING, this can be dangerous for a DiffBasedWorldstate if a concurrent
// WARNING, this can be dangerous for a PathBasedWorldstate if a concurrent
// process attempts to move or modify the head worldstate.
// Ensure no block processing is occuring when using this feature.
// No engine-api, block import, sync, mining or other rpc calls should be running.

2
ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/processor/privateProcessor/PrivateTracer.java
View File

@@ -14,7 +14,7 @@
*/
package org.hyperledger.besu.ethereum.api.jsonrpc.internal.processor.privateProcessor;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

2
ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/query/BlockchainQueries.java
View File

@@ -17,7 +17,7 @@ package org.hyperledger.besu.ethereum.api.query;
import static com.google.common.base.Preconditions.checkArgument;
import static org.hyperledger.besu.ethereum.api.query.cache.TransactionLogBloomCacher.BLOCKS_PER_BLOOM_CACHE;
import static org.hyperledger.besu.ethereum.mainnet.feemarket.ExcessBlobGasCalculator.calculateExcessBlobGasForParent;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

2
ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java
View File

@@ -16,7 +16,7 @@ package org.hyperledger.besu.ethereum.blockcreation;
import static org.hyperledger.besu.ethereum.core.BlockHeaderBuilder.createPending;
import static org.hyperledger.besu.ethereum.mainnet.feemarket.ExcessBlobGasCalculator.calculateExcessBlobGasForParent;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.BlobGas;

2
ethereum/blockcreation/src/test/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockTransactionSelectorTest.java
View File

@@ -80,7 +80,7 @@ import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStoragePrefixedKeyBlockchainStorage;
import org.hyperledger.besu.ethereum.storage.keyvalue.VariablesKeyValueStorage;
import org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.evm.gascalculator.GasCalculator;
import org.hyperledger.besu.evm.gascalculator.LondonGasCalculator;
import org.hyperledger.besu.evm.internal.EvmConfiguration;

2
ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/TraceTransactionIntegrationTest.java
View File

@@ -16,7 +16,7 @@ package org.hyperledger.besu.ethereum.vm;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import org.hyperledger.besu.config.GenesisConfig;
import org.hyperledger.besu.crypto.KeyPair;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/MainnetBlockValidator.java
View File

@@ -28,7 +28,7 @@ import org.hyperledger.besu.ethereum.mainnet.BlockProcessor;
import org.hyperledger.besu.ethereum.mainnet.BodyValidationMode;
import org.hyperledger.besu.ethereum.mainnet.HeaderValidationMode;
import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.plugin.services.exception.StorageException;
import java.util.ArrayList;

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java
View File

@@ -37,8 +37,8 @@ import org.hyperledger.besu.ethereum.mainnet.systemcall.BlockProcessingContext;
import org.hyperledger.besu.ethereum.privacy.storage.PrivateMetadataUpdater;
import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldStateUpdateAccumulator;
import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
import org.hyperledger.besu.evm.tracing.OperationTracer;
import org.hyperledger.besu.evm.worldstate.WorldState;

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/parallelization/MainnetParallelBlockProcessor.java
View File

@@ -32,7 +32,7 @@ import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
import org.hyperledger.besu.ethereum.mainnet.ProtocolSpecBuilder;
import org.hyperledger.besu.ethereum.privacy.storage.PrivateMetadataUpdater;
import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
import org.hyperledger.besu.evm.worldstate.WorldUpdater;
import org.hyperledger.besu.metrics.BesuMetricCategory;
@@ -221,7 +221,7 @@ public class MainnetParallelBlockProcessor extends MainnetBlockProcessor {
final Address miningBeneficiary,
final BlockHashLookup blockHashLookup,
final Wei blobGasPrice) {
if ((protocolContext.getWorldStateArchive() instanceof DiffBasedWorldStateProvider)) {
if ((protocolContext.getWorldStateArchive() instanceof PathBasedWorldStateProvider)) {
ParallelizedConcurrentTransactionProcessor parallelizedConcurrentTransactionProcessor =
new ParallelizedConcurrentTransactionProcessor(transactionProcessor);
// runAsyncBlock, if activated, facilitates the non-blocking parallel execution of

20
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/parallelization/ParallelizedConcurrentTransactionProcessor.java
View File

@@ -24,10 +24,10 @@ import org.hyperledger.besu.ethereum.mainnet.MainnetTransactionProcessor;
import org.hyperledger.besu.ethereum.mainnet.TransactionValidationParams;
import org.hyperledger.besu.ethereum.privacy.storage.PrivateMetadataUpdater;
import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.evm.blockhash.BlockHashLookup;
import org.hyperledger.besu.evm.tracing.OperationTracer;
import org.hyperledger.besu.evm.worldstate.WorldView;
@@ -153,8 +153,8 @@ public class ParallelizedConcurrentTransactionProcessor {
ws.disableCacheMerkleTrieLoader();
final ParallelizedTransactionContext.Builder contextBuilder =
new ParallelizedTransactionContext.Builder();
final DiffBasedWorldStateUpdateAccumulator<?> roundWorldStateUpdater =
(DiffBasedWorldStateUpdateAccumulator<?>) ws.updater();
final PathBasedWorldStateUpdateAccumulator<?> roundWorldStateUpdater =
(PathBasedWorldStateUpdateAccumulator<?>) ws.updater();
final TransactionProcessingResult result =
transactionProcessor.processTransaction(
roundWorldStateUpdater,
@@ -244,16 +244,16 @@ public class ParallelizedConcurrentTransactionProcessor {
final int transactionLocation,
final Optional<Counter> confirmedParallelizedTransactionCounter,
final Optional<Counter> conflictingButCachedTransactionCounter) {
final DiffBasedWorldState diffBasedWorldState = (DiffBasedWorldState) worldState;
final DiffBasedWorldStateUpdateAccumulator blockAccumulator =
(DiffBasedWorldStateUpdateAccumulator) diffBasedWorldState.updater();
final PathBasedWorldState pathBasedWorldState = (PathBasedWorldState) worldState;
final PathBasedWorldStateUpdateAccumulator blockAccumulator =
(PathBasedWorldStateUpdateAccumulator) pathBasedWorldState.updater();
final ParallelizedTransactionContext parallelizedTransactionContext =
parallelizedTransactionContextByLocation.remove(transactionLocation);
/*
* If `parallelizedTransactionContext` is not null, it means that the transaction had time to complete in the background.
*/
if (parallelizedTransactionContext != null) {
final DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator =
final PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator =
parallelizedTransactionContext.transactionAccumulator();
final TransactionProcessingResult transactionProcessingResult =
parallelizedTransactionContext.transactionProcessingResult();

12
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/parallelization/ParallelizedTransactionContext.java
View File

@@ -16,18 +16,18 @@ package org.hyperledger.besu.ethereum.mainnet.parallelization;
import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.processing.TransactionProcessingResult;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import java.util.Objects;
public final class ParallelizedTransactionContext {
private final DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator;
private final PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator;
private final TransactionProcessingResult transactionProcessingResult;
private final boolean isMiningBeneficiaryTouchedPreRewardByTransaction;
private final Wei miningBeneficiaryReward;
public ParallelizedTransactionContext(
final DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator,
final PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator,
final TransactionProcessingResult transactionProcessingResult,
final boolean isMiningBeneficiaryTouchedPreRewardByTransaction,
final Wei miningBeneficiaryReward) {
@@ -38,7 +38,7 @@ public final class ParallelizedTransactionContext {
this.miningBeneficiaryReward = miningBeneficiaryReward;
}
public DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator() {
public PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator() {
return transactionAccumulator;
}
@@ -93,13 +93,13 @@ public final class ParallelizedTransactionContext {
}
public static class Builder {
private DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator;
private PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator;
private TransactionProcessingResult transactionProcessingResult;
private boolean isMiningBeneficiaryTouchedPreRewardByTransaction;
private Wei miningBeneficiaryReward = Wei.ZERO;
public Builder transactionAccumulator(
final DiffBasedWorldStateUpdateAccumulator<?> transactionAccumulator) {
final PathBasedWorldStateUpdateAccumulator<?> transactionAccumulator) {
this.transactionAccumulator = transactionAccumulator;
return this;
}

48
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/parallelization/TransactionCollisionDetector.java
View File

@@ -17,10 +17,10 @@ package org.hyperledger.besu.ethereum.mainnet.parallelization;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.core.Transaction;
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.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.StorageConsumingMap;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.StorageConsumingMap;
import java.util.HashSet;
import java.util.Objects;
@@ -55,7 +55,7 @@ public class TransactionCollisionDetector {
final Transaction transaction,
final Address miningBeneficiary,
final ParallelizedTransactionContext parallelizedTransactionContext,
final DiffBasedWorldStateUpdateAccumulator<? extends DiffBasedAccount> blockAccumulator) {
final PathBasedWorldStateUpdateAccumulator<? extends PathBasedAccount> blockAccumulator) {
final Set<Address> addressesTouchedByTransaction =
getAddressesTouchedByTransaction(
transaction, Optional.of(parallelizedTransactionContext.transactionAccumulator()));
@@ -97,21 +97,21 @@ public class TransactionCollisionDetector {
*/
public Set<Address> getAddressesTouchedByTransaction(
final Transaction transaction,
final Optional<DiffBasedWorldStateUpdateAccumulator<?>> accumulator) {
final Optional<PathBasedWorldStateUpdateAccumulator<?>> accumulator) {
HashSet<Address> addresses = new HashSet<>();
addresses.add(transaction.getSender());
if (transaction.getTo().isPresent()) {
addresses.add(transaction.getTo().get());
}
accumulator.ifPresent(
diffBasedWorldStateUpdateAccumulator -> {
diffBasedWorldStateUpdateAccumulator
pathBasedWorldStateUpdateAccumulator -> {
pathBasedWorldStateUpdateAccumulator
.getAccountsToUpdate()
.forEach(
(address, diffBasedValue) -> {
(address, pathBasedValue) -> {
addresses.add(address);
});
addresses.addAll(diffBasedWorldStateUpdateAccumulator.getDeletedAccountAddresses());
addresses.addAll(pathBasedWorldStateUpdateAccumulator.getDeletedAccountAddresses());
});
return addresses;
@@ -134,12 +134,12 @@ public class TransactionCollisionDetector {
* returned.
*/
private Set<StorageSlotKey> getSlotsTouchedByTransactionAndByAddress(
final Optional<DiffBasedWorldStateUpdateAccumulator<?>> accumulator, final Address address) {
final Optional<PathBasedWorldStateUpdateAccumulator<?>> accumulator, final Address address) {
HashSet<StorageSlotKey> slots = new HashSet<>();
accumulator.ifPresent(
diffBasedWorldStateUpdateAccumulator -> {
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> map =
diffBasedWorldStateUpdateAccumulator.getStorageToUpdate().get(address);
pathBasedWorldStateUpdateAccumulator -> {
final StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> map =
pathBasedWorldStateUpdateAccumulator.getStorageToUpdate().get(address);
if (map != null) {
map.forEach(
(storageSlotKey, slot) -> {
@@ -170,19 +170,19 @@ public class TransactionCollisionDetector {
*/
private Optional<AccountUpdateContext> getAddressTouchedByBlock(
final Address addressToFind,
final Optional<DiffBasedWorldStateUpdateAccumulator<? extends DiffBasedAccount>>
final Optional<PathBasedWorldStateUpdateAccumulator<? extends PathBasedAccount>>
maybeBlockAccumulator) {
if (maybeBlockAccumulator.isPresent()) {
final DiffBasedWorldStateUpdateAccumulator<? extends DiffBasedAccount> blockAccumulator =
final PathBasedWorldStateUpdateAccumulator<? extends PathBasedAccount> blockAccumulator =
maybeBlockAccumulator.get();
final DiffBasedValue<? extends DiffBasedAccount> diffBasedValue =
final PathBasedValue<? extends PathBasedAccount> pathBasedValue =
blockAccumulator.getAccountsToUpdate().get(addressToFind);
if (diffBasedValue != null) {
if (pathBasedValue != null) {
return Optional.of(
new AccountUpdateContext(
addressToFind,
areAccountDetailsEqualExcludingStorage(
diffBasedValue.getPrior(), diffBasedValue.getUpdated())));
pathBasedValue.getPrior(), pathBasedValue.getUpdated())));
}
}
return Optional.empty();
@@ -203,12 +203,12 @@ public class TransactionCollisionDetector {
* are found, or the address has no associated updates, an empty set is returned.
*/
private Set<StorageSlotKey> getSlotsTouchedByBlockAndByAddress(
final Optional<DiffBasedWorldStateUpdateAccumulator<?>> accumulator, final Address address) {
final Optional<PathBasedWorldStateUpdateAccumulator<?>> accumulator, final Address address) {
HashSet<StorageSlotKey> slots = new HashSet<>();
accumulator.ifPresent(
diffBasedWorldStateUpdateAccumulator -> {
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> map =
diffBasedWorldStateUpdateAccumulator.getStorageToUpdate().get(address);
pathBasedWorldStateUpdateAccumulator -> {
final StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> map =
pathBasedWorldStateUpdateAccumulator.getStorageToUpdate().get(address);
if (map != null) {
map.forEach(
(storageSlotKey, slot) -> {
@@ -235,7 +235,7 @@ public class TransactionCollisionDetector {
* @return true if the account state properties are equal excluding storage, false otherwise.
*/
private boolean areAccountDetailsEqualExcludingStorage(
final DiffBasedAccount prior, final DiffBasedAccount next) {
final PathBasedAccount prior, final PathBasedAccount next) {
return (prior == null && next == null)
|| (prior != null
&& next != null

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/precompiles/privacy/FlexiblePrivacyPrecompiledContract.java
View File

@@ -18,7 +18,7 @@ import static org.hyperledger.besu.ethereum.core.PrivacyParameters.FLEXIBLE_PRIV
import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_IS_PERSISTING_PRIVATE_STATE;
import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_PRIVATE_METADATA_UPDATER;
import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION_HASH;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.enclave.Enclave;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/precompiles/privacy/PrivacyPluginPrecompiledContract.java
View File

@@ -14,7 +14,7 @@
*/
package org.hyperledger.besu.ethereum.mainnet.precompiles.privacy;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.MutableWorldState;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/precompiles/privacy/PrivacyPrecompiledContract.java
View File

@@ -18,7 +18,7 @@ import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_IS_PER
import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_PRIVATE_METADATA_UPDATER;
import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION_HASH;
import static org.hyperledger.besu.ethereum.privacy.PrivateStateRootResolver.EMPTY_ROOT_HASH;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/FlexiblePrivacyGroupContract.java
View File

@@ -18,7 +18,7 @@ import static org.hyperledger.besu.ethereum.core.PrivacyParameters.FLEXIBLE_PRIV
import static org.hyperledger.besu.ethereum.privacy.group.FlexibleGroupManagement.CAN_EXECUTE_METHOD_SIGNATURE;
import static org.hyperledger.besu.ethereum.privacy.group.FlexibleGroupManagement.GET_PARTICIPANTS_METHOD_SIGNATURE;
import static org.hyperledger.besu.ethereum.privacy.group.FlexibleGroupManagement.GET_VERSION_METHOD_SIGNATURE;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import org.hyperledger.besu.crypto.SECPSignature;
import org.hyperledger.besu.crypto.SignatureAlgorithm;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateGroupRehydrationBlockProcessor.java
View File

@@ -15,7 +15,7 @@
package org.hyperledger.besu.ethereum.privacy;
import static org.hyperledger.besu.ethereum.privacy.PrivateStateRootResolver.EMPTY_ROOT_HASH;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateStateRehydration.java
View File

@@ -14,7 +14,7 @@
*/
package org.hyperledger.besu.ethereum.privacy;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionSimulator.java
View File

@@ -14,8 +14,8 @@
*/
package org.hyperledger.besu.ethereum.privacy;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withStateRootAndBlockHashAndUpdateNodeHead;
import org.hyperledger.besu.crypto.SECPSignature;
import org.hyperledger.besu.crypto.SignatureAlgorithm;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/storage/migration/PrivateStorageMigration.java
View File

@@ -15,7 +15,7 @@
package org.hyperledger.besu.ethereum.privacy.storage.migration;
import static org.hyperledger.besu.ethereum.privacy.storage.PrivateStateKeyValueStorage.SCHEMA_VERSION_1_4_0;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/processing/TransactionProcessingResult.java
View File

@@ -16,7 +16,7 @@ package org.hyperledger.besu.ethereum.processing;
import org.hyperledger.besu.ethereum.mainnet.ValidationResult;
import org.hyperledger.besu.ethereum.transaction.TransactionInvalidReason;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.evm.log.Log;
import java.util.List;
@@ -55,7 +55,7 @@ public class TransactionProcessingResult
private final ValidationResult<TransactionInvalidReason> validationResult;
private final Optional<Bytes> revertReason;
public DiffBasedWorldStateUpdateAccumulator<?> accumulator;
public PathBasedWorldStateUpdateAccumulator<?> accumulator;
public static TransactionProcessingResult invalid(
final ValidationResult<TransactionInvalidReason> validationResult) {

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

@@ -19,8 +19,8 @@ import org.hyperledger.besu.ethereum.chain.VariablesStorage;
import org.hyperledger.besu.ethereum.mainnet.ProtocolSchedule;
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.forest.storage.ForestWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.WorldStatePreimageStorage;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/transaction/BlockSimulator.java
View File

@@ -15,7 +15,7 @@
package org.hyperledger.besu.ethereum.transaction;
import static org.hyperledger.besu.ethereum.transaction.BlockStateCalls.fillBlockStateCalls;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/transaction/TransactionSimulator.java
View File

@@ -16,7 +16,7 @@ package org.hyperledger.besu.ethereum.transaction;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.hyperledger.besu.ethereum.mainnet.feemarket.ExcessBlobGasCalculator.calculateExcessBlobGasForParent;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.crypto.SECPSignature;
import org.hyperledger.besu.crypto.SignatureAlgorithm;

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

@@ -14,18 +14,18 @@
*/
package org.hyperledger.besu.ethereum.trie.common;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig.createStatefulConfigWithTrie;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig.createStatefulConfigWithTrie;
import org.hyperledger.besu.ethereum.core.MutableWorldState;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.WorldStatePreimageKeyValueStorage;
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.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.NoOpTrieLogManager;
import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.forest.worldview.ForestMutableWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.NoOpBonsaiCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.NoOpTrieLogManager;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/forest/ForestWorldStateArchive.java
View File

@@ -21,9 +21,9 @@ import org.hyperledger.besu.ethereum.core.MutableWorldState;
import org.hyperledger.besu.ethereum.proof.WorldStateProof;
import org.hyperledger.besu.ethereum.proof.WorldStateProofProvider;
import org.hyperledger.besu.ethereum.trie.MerkleTrie;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.forest.worldview.ForestMutableWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.ethereum.worldstate.WorldStatePreimageStorage;
import org.hyperledger.besu.ethereum.worldstate.WorldStateStorageCoordinator;

20
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/BonsaiAccount.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/BonsaiAccount.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai;
import org.hyperledger.besu.datatypes.AccountValue;
import org.hyperledger.besu.datatypes.Address;
@@ -22,9 +22,9 @@ import org.hyperledger.besu.ethereum.rlp.RLP;
import org.hyperledger.besu.ethereum.rlp.RLPException;
import org.hyperledger.besu.ethereum.rlp.RLPInput;
import org.hyperledger.besu.ethereum.rlp.RLPOutput;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedAccount;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldView;
import org.hyperledger.besu.evm.ModificationNotAllowedException;
import org.hyperledger.besu.evm.account.AccountStorageEntry;
import org.hyperledger.besu.evm.worldstate.UpdateTrackingAccount;
@@ -35,11 +35,11 @@ import java.util.Objects;
import org.apache.tuweni.bytes.Bytes;
import org.apache.tuweni.bytes.Bytes32;
public class BonsaiAccount extends DiffBasedAccount {
public class BonsaiAccount extends PathBasedAccount {
private Hash storageRoot;
public BonsaiAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final Hash addressHash,
final long nonce,
@@ -52,7 +52,7 @@ public class BonsaiAccount extends DiffBasedAccount {
}
public BonsaiAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final AccountValue stateTrieAccount,
final boolean mutable) {
@@ -72,7 +72,7 @@ public class BonsaiAccount extends DiffBasedAccount {
}
public BonsaiAccount(
final BonsaiAccount toCopy, final DiffBasedWorldView context, final boolean mutable) {
final BonsaiAccount toCopy, final PathBasedWorldView context, final boolean mutable) {
super(
context,
toCopy.address,
@@ -87,7 +87,7 @@ public class BonsaiAccount extends DiffBasedAccount {
}
public BonsaiAccount(
final DiffBasedWorldView context, final UpdateTrackingAccount<BonsaiAccount> tracked) {
final PathBasedWorldView context, final UpdateTrackingAccount<BonsaiAccount> tracked) {
super(
context,
tracked.getAddress(),
@@ -102,7 +102,7 @@ public class BonsaiAccount extends DiffBasedAccount {
}
public static BonsaiAccount fromRLP(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final Bytes encoded,
final boolean mutable)

16
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/BonsaiWorldStateProvider.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/BonsaiWorldStateProvider.java
View File

@@ -12,19 +12,19 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;
import org.hyperledger.besu.ethereum.rlp.RLP;
import org.hyperledger.besu.ethereum.trie.common.PmtStateTrieAccountValue;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.patricia.StoredMerklePatriciaTrie;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.plugin.ServiceManager;
@@ -40,7 +40,7 @@ import org.apache.tuweni.bytes.Bytes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BonsaiWorldStateProvider extends DiffBasedWorldStateProvider {
public class BonsaiWorldStateProvider extends PathBasedWorldStateProvider {
private static final Logger LOG = LoggerFactory.getLogger(BonsaiWorldStateProvider.class);
private final BonsaiCachedMerkleTrieLoader bonsaiCachedMerkleTrieLoader;

6
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/cache/BonsaiCachedMerkleTrieLoader.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/cache/BonsaiCachedMerkleTrieLoader.java vendored
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache;
import static org.hyperledger.besu.metrics.BesuMetricCategory.BLOCKCHAIN;
@@ -21,8 +21,8 @@ import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.trie.MerkleTrie;
import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.patricia.StoredMerklePatriciaTrie;
import org.hyperledger.besu.metrics.ObservableMetricsSystem;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/cache/BonsaiCachedMerkleTrieLoaderModule.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/cache/BonsaiCachedMerkleTrieLoaderModule.java vendored
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache;
import org.hyperledger.besu.metrics.ObservableMetricsSystem;
import org.hyperledger.besu.plugin.services.MetricsSystem;

40
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/cache/BonsaiCachedWorldStorageManager.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/cache/BonsaiCachedWorldStorageManager.java vendored
View File

@@ -12,33 +12,33 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiSnapshotWorldStateKeyValueStorage;
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;
import org.hyperledger.besu.ethereum.trie.diffbased.common.cache.DiffBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiSnapshotWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateLayerStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.cache.PathBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
public class BonsaiCachedWorldStorageManager extends DiffBasedCachedWorldStorageManager {
public class BonsaiCachedWorldStorageManager extends PathBasedCachedWorldStorageManager {
public BonsaiCachedWorldStorageManager(
final BonsaiWorldStateProvider archive,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final WorldStateConfig worldStateConfig) {
super(archive, worldStateKeyValueStorage, worldStateConfig);
}
@Override
public DiffBasedWorldState createWorldState(
final DiffBasedWorldStateProvider archive,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
public PathBasedWorldState createWorldState(
final PathBasedWorldStateProvider archive,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final EvmConfiguration evmConfiguration) {
return new BonsaiWorldState(
(BonsaiWorldStateProvider) archive,
@@ -48,15 +48,15 @@ public class BonsaiCachedWorldStorageManager extends DiffBasedCachedWorldStorage
}
@Override
public DiffBasedWorldStateKeyValueStorage createLayeredKeyValueStorage(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage) {
public PathBasedWorldStateKeyValueStorage createLayeredKeyValueStorage(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage) {
return new BonsaiWorldStateLayerStorage(
(BonsaiWorldStateKeyValueStorage) worldStateKeyValueStorage);
}
@Override
public DiffBasedWorldStateKeyValueStorage createSnapshotKeyValueStorage(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage) {
public PathBasedWorldStateKeyValueStorage createSnapshotKeyValueStorage(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage) {
return new BonsaiSnapshotWorldStateKeyValueStorage(
(BonsaiWorldStateKeyValueStorage) worldStateKeyValueStorage);
}

16
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/cache/NoOpBonsaiCachedWorldStorageManager.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/cache/NoOpBonsaiCachedWorldStorageManager.java vendored
View File

@@ -12,13 +12,13 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig;
import java.util.Optional;
import java.util.function.Function;
@@ -34,7 +34,7 @@ public class NoOpBonsaiCachedWorldStorageManager extends BonsaiCachedWorldStorag
public synchronized void addCachedLayer(
final BlockHeader blockHeader,
final Hash worldStateRootHash,
final DiffBasedWorldState forWorldState) {
final PathBasedWorldState forWorldState) {
// no cache
}
@@ -44,17 +44,17 @@ public class NoOpBonsaiCachedWorldStorageManager extends BonsaiCachedWorldStorag
}
@Override
public Optional<DiffBasedWorldState> getWorldState(final Hash blockHash) {
public Optional<PathBasedWorldState> getWorldState(final Hash blockHash) {
return Optional.empty();
}
@Override
public Optional<DiffBasedWorldState> getNearestWorldState(final BlockHeader blockHeader) {
public Optional<PathBasedWorldState> getNearestWorldState(final BlockHeader blockHeader) {
return Optional.empty();
}
@Override
public Optional<DiffBasedWorldState> getHeadWorldState(
public Optional<PathBasedWorldState> getHeadWorldState(
final Function<Hash, Optional<BlockHeader>> hashBlockHeaderFunction) {
return Optional.empty();
}

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/cache/NoopBonsaiCachedMerkleTrieLoader.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/cache/NoopBonsaiCachedMerkleTrieLoader.java vendored
View File

@@ -12,12 +12,12 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache;
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.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.metrics.noop.NoOpMetricsSystem;
public class NoopBonsaiCachedMerkleTrieLoader extends BonsaiCachedMerkleTrieLoader {

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiPreImageProxy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/BonsaiPreImageProxy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;

8
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiSnapshotWorldStateKeyValueStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/BonsaiSnapshotWorldStateKeyValueStorage.java
View File

@@ -12,12 +12,12 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedSnapshotWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedSnapshotWorldStateKeyValueStorage;
import org.hyperledger.besu.plugin.services.exception.StorageException;
import org.hyperledger.besu.plugin.services.storage.KeyValueStorage;
import org.hyperledger.besu.plugin.services.storage.SnappableKeyValueStorage;
@@ -32,7 +32,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BonsaiSnapshotWorldStateKeyValueStorage extends BonsaiWorldStateKeyValueStorage
implements DiffBasedSnapshotWorldStateKeyValueStorage, StorageSubscriber {
implements PathBasedSnapshotWorldStateKeyValueStorage, StorageSubscriber {
protected final BonsaiWorldStateKeyValueStorage parentWorldStateStorage;
private static final Logger LOG =

14
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/BonsaiWorldStateKeyValueStorage.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_INFO_STATE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_STORAGE_STORAGE;
@@ -25,10 +25,10 @@ import org.hyperledger.besu.ethereum.storage.StorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier;
import org.hyperledger.besu.ethereum.trie.MerkleTrie;
import org.hyperledger.besu.ethereum.trie.common.PmtStateTrieAccountValue;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat.BonsaiFlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat.BonsaiFlatDbStrategyProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat.BonsaiFlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat.BonsaiFlatDbStrategyProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
@@ -48,7 +48,7 @@ import java.util.function.Supplier;
import org.apache.tuweni.bytes.Bytes;
import org.apache.tuweni.bytes.Bytes32;
public class BonsaiWorldStateKeyValueStorage extends DiffBasedWorldStateKeyValueStorage
public class BonsaiWorldStateKeyValueStorage extends PathBasedWorldStateKeyValueStorage
implements WorldStateKeyValueStorage {
protected final BonsaiFlatDbStrategyProvider flatDbStrategyProvider;
@@ -190,7 +190,7 @@ public class BonsaiWorldStateKeyValueStorage extends DiffBasedWorldStateKeyValue
getFlatDbStrategy());
}
public static class Updater implements DiffBasedWorldStateKeyValueStorage.Updater {
public static class Updater implements PathBasedWorldStateKeyValueStorage.Updater {
private final SegmentedKeyValueStorageTransaction composedWorldStateTransaction;
private final KeyValueStorageTransaction trieLogStorageTransaction;

8
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/BonsaiWorldStateLayerStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/BonsaiWorldStateLayerStorage.java
View File

@@ -12,17 +12,17 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
import org.hyperledger.besu.plugin.services.storage.KeyValueStorage;
import org.hyperledger.besu.plugin.services.storage.SnappedKeyValueStorage;
import org.hyperledger.besu.services.kvstore.LayeredKeyValueStorage;
public class BonsaiWorldStateLayerStorage extends BonsaiSnapshotWorldStateKeyValueStorage
implements DiffBasedLayeredWorldStateKeyValueStorage, StorageSubscriber {
implements PathBasedLayeredWorldStateKeyValueStorage, StorageSubscriber {
public BonsaiWorldStateLayerStorage(final BonsaiWorldStateKeyValueStorage parent) {
this(

6
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/flat/BonsaiFlatDbStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/flat/BonsaiFlatDbStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_INFO_STATE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_STORAGE_STORAGE;
@@ -21,8 +21,8 @@ import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIden
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.trie.NodeLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.plugin.services.MetricsSystem;
import org.hyperledger.besu.plugin.services.storage.SegmentedKeyValueStorage;
import org.hyperledger.besu.plugin.services.storage.SegmentedKeyValueStorageTransaction;

10
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/flat/BonsaiFlatDbStrategyProvider.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/flat/BonsaiFlatDbStrategyProvider.java
View File

@@ -12,13 +12,13 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.TRIE_BRANCH_STORAGE;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategyProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.FlatDbStrategyProvider;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
import org.hyperledger.besu.plugin.services.MetricsSystem;
@@ -41,7 +41,7 @@ public class BonsaiFlatDbStrategyProvider extends FlatDbStrategyProvider {
protected FlatDbMode getRequestedFlatDbMode(
final DataStorageConfiguration dataStorageConfiguration) {
return dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getFullFlatDbEnabled()
? FlatDbMode.FULL

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/flat/BonsaiFullFlatDbStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/flat/BonsaiFullFlatDbStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_INFO_STATE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_STORAGE_STORAGE;
@@ -20,7 +20,7 @@ import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIden
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.trie.NodeLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.metrics.BesuMetricCategory;
import org.hyperledger.besu.plugin.services.MetricsSystem;
import org.hyperledger.besu.plugin.services.metrics.Counter;

4
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/storage/flat/BonsaiPartialFlatDbStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/storage/flat/BonsaiPartialFlatDbStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_INFO_STATE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_STORAGE_STORAGE;
@@ -20,7 +20,7 @@ import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIden
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.ethereum.trie.NodeLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.CodeStorageStrategy;
import org.hyperledger.besu.ethereum.trie.patricia.StoredMerklePatriciaTrie;
import org.hyperledger.besu.ethereum.trie.patricia.StoredNodeFactory;
import org.hyperledger.besu.metrics.BesuMetricCategory;

14
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/trielog/TrieLogFactoryImpl.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/trielog/TrieLogFactoryImpl.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.trielog;
import org.hyperledger.besu.datatypes.AccountValue;
import org.hyperledger.besu.datatypes.Address;
@@ -23,8 +23,8 @@ import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
import org.hyperledger.besu.ethereum.rlp.RLPInput;
import org.hyperledger.besu.ethereum.rlp.RLPOutput;
import org.hyperledger.besu.ethereum.trie.common.PmtStateTrieAccountValue;
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogLayer;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogLayer;
import org.hyperledger.besu.plugin.data.BlockHeader;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
import org.hyperledger.besu.plugin.services.trielogs.TrieLogAccumulator;
@@ -168,7 +168,7 @@ public class TrieLogFactoryImpl implements TrieLogFactory {
input.leaveList();
newLayer
.getAccountChanges()
.put(address, new DiffBasedValue<>(oldValue, newValue, isCleared));
.put(address, new PathBasedValue<>(oldValue, newValue, isCleared));
}
if (input.nextIsNull()) {
@@ -179,13 +179,13 @@ public class TrieLogFactoryImpl implements TrieLogFactory {
final Bytes newCode = nullOrValue(input, RLPInput::readBytes);
final boolean isCleared = getOptionalIsCleared(input);
input.leaveList();
newLayer.getCodeChanges().put(address, new DiffBasedValue<>(oldCode, newCode, isCleared));
newLayer.getCodeChanges().put(address, new PathBasedValue<>(oldCode, newCode, isCleared));
}
if (input.nextIsNull()) {
input.skipNext();
} else {
final Map<StorageSlotKey, DiffBasedValue<UInt256>> storageChanges = new TreeMap<>();
final Map<StorageSlotKey, PathBasedValue<UInt256>> storageChanges = new TreeMap<>();
input.enterList();
while (!input.isEndOfCurrentList()) {
input.enterList();
@@ -194,7 +194,7 @@ public class TrieLogFactoryImpl implements TrieLogFactory {
final UInt256 oldValue = nullOrValue(input, RLPInput::readUInt256Scalar);
final UInt256 newValue = nullOrValue(input, RLPInput::readUInt256Scalar);
final boolean isCleared = getOptionalIsCleared(input);
storageChanges.put(storageSlotKey, new DiffBasedValue<>(oldValue, newValue, isCleared));
storageChanges.put(storageSlotKey, new PathBasedValue<>(oldValue, newValue, isCleared));
input.leaveList();
}
input.leaveList();

58
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldState.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/worldview/BonsaiWorldState.java
View File

@@ -12,10 +12,10 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.TRIE_BRANCH_STORAGE;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView.encodeTrieValue;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldView.encodeTrieValue;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
@@ -25,20 +25,20 @@ import org.hyperledger.besu.ethereum.trie.MerkleTrie;
import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
import org.hyperledger.besu.ethereum.trie.NoOpMerkleTrie;
import org.hyperledger.besu.ethereum.trie.NodeLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.NoopBonsaiCachedMerkleTrieLoader;
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.DiffBasedValue;
import org.hyperledger.besu.ethereum.trie.diffbased.common.cache.DiffBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.StorageConsumingMap;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.NoopBonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateLayerStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.cache.PathBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.StorageConsumingMap;
import org.hyperledger.besu.ethereum.trie.patricia.StoredMerklePatriciaTrie;
import org.hyperledger.besu.evm.account.Account;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
@@ -59,7 +59,7 @@ import org.apache.tuweni.bytes.Bytes32;
import org.apache.tuweni.rlp.RLP;
import org.apache.tuweni.units.bigints.UInt256;
public class BonsaiWorldState extends DiffBasedWorldState {
public class BonsaiWorldState extends PathBasedWorldState {
protected BonsaiCachedMerkleTrieLoader bonsaiCachedMerkleTrieLoader;
@@ -80,7 +80,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
public BonsaiWorldState(
final BonsaiWorldStateKeyValueStorage worldStateKeyValueStorage,
final BonsaiCachedMerkleTrieLoader bonsaiCachedMerkleTrieLoader,
final DiffBasedCachedWorldStorageManager cachedWorldStorageManager,
final PathBasedCachedWorldStorageManager cachedWorldStorageManager,
final TrieLogManager trieLogManager,
final EvmConfiguration evmConfiguration,
final WorldStateConfig worldStateConfig) {
@@ -111,8 +111,8 @@ public class BonsaiWorldState extends DiffBasedWorldState {
@Override
protected Hash calculateRootHash(
final Optional<DiffBasedWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final DiffBasedWorldStateUpdateAccumulator<?> worldStateUpdater) {
final Optional<PathBasedWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final PathBasedWorldStateUpdateAccumulator<?> worldStateUpdater) {
return internalCalculateRootHash(
maybeStateUpdater.map(BonsaiWorldStateKeyValueStorage.Updater.class::cast),
(BonsaiWorldStateUpdateAccumulator) worldStateUpdater);
@@ -126,7 +126,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
// This must be done before updating the accounts so
// that we can get the storage state hash
Stream<Map.Entry<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>>>
Stream<Map.Entry<Address, StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>>>>
storageStream = worldStateUpdater.getStorageToUpdate().entrySet().stream();
if (maybeStateUpdater.isEmpty()) {
storageStream =
@@ -170,10 +170,10 @@ public class BonsaiWorldState extends DiffBasedWorldState {
final Optional<BonsaiWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final BonsaiWorldStateUpdateAccumulator worldStateUpdater,
final MerkleTrie<Bytes, Bytes> accountTrie) {
for (final Map.Entry<Address, DiffBasedValue<BonsaiAccount>> accountUpdate :
for (final Map.Entry<Address, PathBasedValue<BonsaiAccount>> accountUpdate :
worldStateUpdater.getAccountsToUpdate().entrySet()) {
final Bytes accountKey = accountUpdate.getKey();
final DiffBasedValue<BonsaiAccount> bonsaiValue = accountUpdate.getValue();
final PathBasedValue<BonsaiAccount> bonsaiValue = accountUpdate.getValue();
final BonsaiAccount updatedAccount = bonsaiValue.getUpdated();
try {
if (updatedAccount == null) {
@@ -203,7 +203,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
final BonsaiWorldStateUpdateAccumulator worldStateUpdater) {
maybeStateUpdater.ifPresent(
bonsaiUpdater -> {
for (final Map.Entry<Address, DiffBasedValue<Bytes>> codeUpdate :
for (final Map.Entry<Address, PathBasedValue<Bytes>> codeUpdate :
worldStateUpdater.getCodeToUpdate().entrySet()) {
final Bytes updatedCode = codeUpdate.getValue().getUpdated();
final Hash accountHash = codeUpdate.getKey().addressHash();
@@ -233,12 +233,12 @@ public class BonsaiWorldState extends DiffBasedWorldState {
private void updateAccountStorageState(
final Optional<BonsaiWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final BonsaiWorldStateUpdateAccumulator worldStateUpdater,
final Map.Entry<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>>
final Map.Entry<Address, StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>>>
storageAccountUpdate) {
final Address updatedAddress = storageAccountUpdate.getKey();
final Hash updatedAddressHash = updatedAddress.addressHash();
if (worldStateUpdater.getAccountsToUpdate().containsKey(updatedAddress)) {
final DiffBasedValue<BonsaiAccount> accountValue =
final PathBasedValue<BonsaiAccount> accountValue =
worldStateUpdater.getAccountsToUpdate().get(updatedAddress);
final BonsaiAccount accountOriginal = accountValue.getPrior();
final Hash storageRoot =
@@ -254,7 +254,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
storageRoot);
// for manicured tries and composting, collect branches here (not implemented)
for (final Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>> storageUpdate :
for (final Map.Entry<StorageSlotKey, PathBasedValue<UInt256>> storageUpdate :
storageAccountUpdate.getValue().entrySet()) {
final Hash slotHash = storageUpdate.getKey().getSlotHash();
final UInt256 updatedStorage = storageUpdate.getValue().getUpdated();
@@ -320,7 +320,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
(location, key) -> getStorageTrieNode(addressHash, location, key),
oldAccount.getStorageRoot());
try {
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> storageToDelete =
final StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> storageToDelete =
worldStateUpdater.getStorageToUpdate().get(address);
Map<Bytes32, Bytes> entriesToDelete = storageTrie.entriesFrom(Bytes32.ZERO, 256);
while (!entriesToDelete.isEmpty()) {
@@ -335,7 +335,7 @@ public class BonsaiWorldState extends DiffBasedWorldState {
address.addressHash(), storageSlotKey.getSlotHash()));
storageToDelete
.computeIfAbsent(
storageSlotKey, key -> new DiffBasedValue<>(slotValue, null, true))
storageSlotKey, key -> new PathBasedValue<>(slotValue, null, true))
.setPrior(slotValue);
});
entriesToDelete.keySet().forEach(storageTrie::remove);

28
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/bonsai/worldview/BonsaiWorldStateUpdateAccumulator.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/bonsai/worldview/BonsaiWorldStateUpdateAccumulator.java
View File

@@ -12,33 +12,33 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview;
package org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview;
import org.hyperledger.besu.datatypes.AccountValue;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.StorageSlotKey;
import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.Consumer;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldView;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.Consumer;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import org.hyperledger.besu.evm.worldstate.UpdateTrackingAccount;
public class BonsaiWorldStateUpdateAccumulator
extends DiffBasedWorldStateUpdateAccumulator<BonsaiAccount> {
extends PathBasedWorldStateUpdateAccumulator<BonsaiAccount> {
public BonsaiWorldStateUpdateAccumulator(
final DiffBasedWorldView world,
final Consumer<DiffBasedValue<BonsaiAccount>> accountPreloader,
final PathBasedWorldView world,
final Consumer<PathBasedValue<BonsaiAccount>> accountPreloader,
final Consumer<StorageSlotKey> storagePreloader,
final EvmConfiguration evmConfiguration) {
super(world, accountPreloader, storagePreloader, evmConfiguration);
}
@Override
public DiffBasedWorldStateUpdateAccumulator<BonsaiAccount> copy() {
public PathBasedWorldStateUpdateAccumulator<BonsaiAccount> copy() {
final BonsaiWorldStateUpdateAccumulator copy =
new BonsaiWorldStateUpdateAccumulator(
wrappedWorldView(),
@@ -56,13 +56,13 @@ public class BonsaiWorldStateUpdateAccumulator
@Override
protected BonsaiAccount copyAccount(
final BonsaiAccount toCopy, final DiffBasedWorldView context, final boolean mutable) {
final BonsaiAccount toCopy, final PathBasedWorldView context, final boolean mutable) {
return new BonsaiAccount(toCopy, context, mutable);
}
@Override
protected BonsaiAccount createAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final AccountValue stateTrieAccount,
final boolean mutable) {
@@ -71,7 +71,7 @@ public class BonsaiWorldStateUpdateAccumulator
@Override
protected BonsaiAccount createAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final Hash addressHash,
final long nonce,
@@ -85,7 +85,7 @@ public class BonsaiWorldStateUpdateAccumulator
@Override
protected BonsaiAccount createAccount(
final DiffBasedWorldView context, final UpdateTrackingAccount<BonsaiAccount> tracked) {
final PathBasedWorldView context, final UpdateTrackingAccount<BonsaiAccount> tracked) {
return new BonsaiAccount(context, tracked);
}

24
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/DiffBasedAccount.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/PathBasedAccount.java
View File

@@ -12,14 +12,14 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common;
package org.hyperledger.besu.ethereum.trie.pathbased.common;
import org.hyperledger.besu.datatypes.AccountValue;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldView;
import org.hyperledger.besu.evm.ModificationNotAllowedException;
import org.hyperledger.besu.evm.account.MutableAccount;
@@ -29,8 +29,8 @@ import java.util.Map;
import org.apache.tuweni.bytes.Bytes;
import org.apache.tuweni.units.bigints.UInt256;
public abstract class DiffBasedAccount implements MutableAccount, AccountValue {
protected final DiffBasedWorldView context;
public abstract class PathBasedAccount implements MutableAccount, AccountValue {
protected final PathBasedWorldView context;
protected boolean immutable;
protected final Address address;
protected final Hash addressHash;
@@ -42,12 +42,12 @@ public abstract class DiffBasedAccount implements MutableAccount, AccountValue {
protected final Map<UInt256, UInt256> updatedStorage = new HashMap<>();
/**
* Constructs a new DiffBasedAccount instance without the account's code. This constructor is used
* Constructs a new PathBasedAccount instance without the account's code. This constructor is used
* when the account's code is not required or will not be read from the database. It initializes
* the account with its context, address, address hash, nonce, balance, code hash, and mutability
* status.
*
* @param context The DiffBasedWorldView context in which this account exists.
* @param context The PathBasedWorldView context in which this account exists.
* @param address The Ethereum address of this account.
* @param addressHash The hash of the account's address.
* @param nonce The nonce of the account, representing the number of transactions sent from this
@@ -57,8 +57,8 @@ public abstract class DiffBasedAccount implements MutableAccount, AccountValue {
* @param mutable A boolean indicating if the account is mutable. If false, the account is
* considered immutable.
*/
public DiffBasedAccount(
final DiffBasedWorldView context,
public PathBasedAccount(
final PathBasedWorldView context,
final Address address,
final Hash addressHash,
final long nonce,
@@ -76,12 +76,12 @@ public abstract class DiffBasedAccount implements MutableAccount, AccountValue {
}
/**
* Constructs a new DiffBasedAccount instance with the account's code. This constructor is used
* Constructs a new PathBasedAccount instance with the account's code. This constructor is used
* when all account information, including its code, are available. It initializes the account
* with its context, address, address hash, nonce, balance, code hash, the actual code, and
* mutability status.
*
* @param context The DiffBasedWorldView context in which this account exists.
* @param context The PathBasedWorldView context in which this account exists.
* @param address The Ethereum address of this account.
* @param addressHash The hash of the account's address.
* @param nonce The nonce of the account, representing the number of transactions sent from this
@@ -93,8 +93,8 @@ public abstract class DiffBasedAccount implements MutableAccount, AccountValue {
* @param mutable A boolean indicating if the account is mutable. If false, the account is
* considered immutable.
*/
public DiffBasedAccount(
final DiffBasedWorldView context,
public PathBasedAccount(
final PathBasedWorldView context,
final Address address,
final Hash addressHash,
final long nonce,

22
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/DiffBasedValue.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/PathBasedValue.java
View File

@@ -12,35 +12,35 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common;
package org.hyperledger.besu.ethereum.trie.pathbased.common;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
public class DiffBasedValue<T> implements TrieLog.LogTuple<T> {
public class PathBasedValue<T> implements TrieLog.LogTuple<T> {
private T prior;
private T updated;
private boolean lastStepCleared;
private boolean clearedAtLeastOnce;
public DiffBasedValue(final T prior, final T updated) {
public PathBasedValue(final T prior, final T updated) {
this.prior = prior;
this.updated = updated;
this.lastStepCleared = false;
this.clearedAtLeastOnce = false;
}
public DiffBasedValue(final T prior, final T updated, final boolean lastStepCleared) {
public PathBasedValue(final T prior, final T updated, final boolean lastStepCleared) {
this.prior = prior;
this.updated = updated;
this.lastStepCleared = lastStepCleared;
this.clearedAtLeastOnce = lastStepCleared;
}
public DiffBasedValue(
public PathBasedValue(
final T prior,
final T updated,
final boolean lastStepCleared,
@@ -61,12 +61,12 @@ public class DiffBasedValue<T> implements TrieLog.LogTuple<T> {
return updated;
}
public DiffBasedValue<T> setPrior(final T prior) {
public PathBasedValue<T> setPrior(final T prior) {
this.prior = prior;
return this;
}
public DiffBasedValue<T> setUpdated(final T updated) {
public PathBasedValue<T> setUpdated(final T updated) {
this.lastStepCleared = updated == null;
if (lastStepCleared) {
this.clearedAtLeastOnce = true;
@@ -92,7 +92,7 @@ public class DiffBasedValue<T> implements TrieLog.LogTuple<T> {
@Override
public String toString() {
return "DiffBasedValue{"
return "PathBasedValue{"
+ "prior="
+ prior
+ ", updated="
@@ -110,7 +110,7 @@ public class DiffBasedValue<T> implements TrieLog.LogTuple<T> {
if (o == null || getClass() != o.getClass()) {
return false;
}
DiffBasedValue<?> that = (DiffBasedValue<?>) o;
PathBasedValue<?> that = (PathBasedValue<?>) o;
return new EqualsBuilder()
.append(lastStepCleared, that.lastStepCleared)
.append(prior, that.prior)
@@ -127,7 +127,7 @@ public class DiffBasedValue<T> implements TrieLog.LogTuple<T> {
.toHashCode();
}
public DiffBasedValue<T> copy() {
return new DiffBasedValue<T>(prior, updated, lastStepCleared, clearedAtLeastOnce);
public PathBasedValue<T> copy() {
return new PathBasedValue<T>(prior, updated, lastStepCleared, clearedAtLeastOnce);
}
}

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/StorageSubscriber.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/StorageSubscriber.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common;
package org.hyperledger.besu.ethereum.trie.pathbased.common;
public interface StorageSubscriber {
default void onClearStorage() {}

92
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/cache/DiffBasedCachedWorldStorageManager.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/cache/PathBasedCachedWorldStorageManager.java vendored
View File

@@ -12,20 +12,20 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.common.cache;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.DiffBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.PathBasedWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
import java.util.ArrayList;
@@ -43,11 +43,11 @@ import org.apache.tuweni.bytes.Bytes32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class DiffBasedCachedWorldStorageManager implements StorageSubscriber {
public abstract class PathBasedCachedWorldStorageManager implements StorageSubscriber {
public static final long RETAINED_LAYERS = 512; // at least 256 + typical rollbacks
private static final Logger LOG =
LoggerFactory.getLogger(DiffBasedCachedWorldStorageManager.class);
private final DiffBasedWorldStateProvider archive;
LoggerFactory.getLogger(PathBasedCachedWorldStorageManager.class);
private final PathBasedWorldStateProvider archive;
private final EvmConfiguration evmConfiguration;
protected final WorldStateConfig worldStateConfig;
private final Cache<Hash, BlockHeader> stateRootToBlockHeaderCache =
@@ -56,13 +56,13 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
.expireAfterWrite(100, TimeUnit.MINUTES)
.build();
private final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage;
private final Map<Bytes32, DiffBasedCachedWorldView> cachedWorldStatesByHash;
private final PathBasedWorldStateKeyValueStorage rootWorldStateStorage;
private final Map<Bytes32, PathBasedCachedWorldView> cachedWorldStatesByHash;
private DiffBasedCachedWorldStorageManager(
final DiffBasedWorldStateProvider archive,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final Map<Bytes32, DiffBasedCachedWorldView> cachedWorldStatesByHash,
private PathBasedCachedWorldStorageManager(
final PathBasedWorldStateProvider archive,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final Map<Bytes32, PathBasedCachedWorldView> cachedWorldStatesByHash,
final EvmConfiguration evmConfiguration,
final WorldStateConfig worldStateConfig) {
worldStateKeyValueStorage.subscribe(this);
@@ -73,9 +73,9 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
this.worldStateConfig = worldStateConfig;
}
public DiffBasedCachedWorldStorageManager(
final DiffBasedWorldStateProvider archive,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
public PathBasedCachedWorldStorageManager(
final PathBasedWorldStateProvider archive,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final WorldStateConfig worldStateConfig) {
this(
archive,
@@ -88,20 +88,20 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
public synchronized void addCachedLayer(
final BlockHeader blockHeader,
final Hash worldStateRootHash,
final DiffBasedWorldState forWorldState) {
final Optional<DiffBasedCachedWorldView> cachedDiffBasedWorldView =
final PathBasedWorldState forWorldState) {
final Optional<PathBasedCachedWorldView> cachedPathBasedWorldView =
Optional.ofNullable(this.cachedWorldStatesByHash.get(blockHeader.getBlockHash()));
if (cachedDiffBasedWorldView.isPresent()) {
if (cachedPathBasedWorldView.isPresent()) {
// only replace if it is a layered storage
if (forWorldState.isModifyingHeadWorldState()
&& cachedDiffBasedWorldView.get().getWorldStateStorage()
instanceof DiffBasedLayeredWorldStateKeyValueStorage) {
&& cachedPathBasedWorldView.get().getWorldStateStorage()
instanceof PathBasedLayeredWorldStateKeyValueStorage) {
LOG.atDebug()
.setMessage("updating layered world state for block {}, state root hash {}")
.addArgument(blockHeader::toLogString)
.addArgument(worldStateRootHash::toShortHexString)
.log();
cachedDiffBasedWorldView
cachedPathBasedWorldView
.get()
.updateWorldStateStorage(
createSnapshotKeyValueStorage(forWorldState.getWorldStateStorage()));
@@ -115,15 +115,15 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
if (forWorldState.isModifyingHeadWorldState()) {
cachedWorldStatesByHash.put(
blockHeader.getHash(),
new DiffBasedCachedWorldView(
new PathBasedCachedWorldView(
blockHeader, createSnapshotKeyValueStorage(forWorldState.getWorldStateStorage())));
} else {
// otherwise, add the layer to the cache
cachedWorldStatesByHash.put(
blockHeader.getHash(),
new DiffBasedCachedWorldView(
new PathBasedCachedWorldView(
blockHeader,
((DiffBasedLayeredWorldStateKeyValueStorage) forWorldState.getWorldStateStorage())
((PathBasedLayeredWorldStateKeyValueStorage) forWorldState.getWorldStateStorage())
.clone()));
}
// add stateroot -> blockHeader cache entry
@@ -146,7 +146,7 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
}
}
public Optional<DiffBasedWorldState> getWorldState(final Hash blockHash) {
public Optional<PathBasedWorldState> getWorldState(final Hash blockHash) {
if (cachedWorldStatesByHash.containsKey(blockHash)) {
// return a new worldstate using worldstate storage and an isolated copy of the updater
return Optional.ofNullable(cachedWorldStatesByHash.get(blockHash))
@@ -165,7 +165,7 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
return Optional.empty();
}
public Optional<DiffBasedWorldState> getNearestWorldState(final BlockHeader blockHeader) {
public Optional<PathBasedWorldState> getNearestWorldState(final BlockHeader blockHeader) {
LOG.atDebug()
.setMessage("getting nearest worldstate for {}")
.addArgument(blockHeader.toLogString())
@@ -173,7 +173,7 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
return Optional.ofNullable(
cachedWorldStatesByHash.get(blockHeader.getParentHash())) // search parent block
.map(DiffBasedCachedWorldView::getWorldStateStorage)
.map(PathBasedCachedWorldView::getWorldStateStorage)
.or(
() -> {
// or else search the nearest state in the cache
@@ -182,13 +182,13 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
.addArgument(blockHeader.toLogString())
.log();
final List<DiffBasedCachedWorldView> cachedDiffBasedWorldViews =
final List<PathBasedCachedWorldView> cachedPathBasedWorldViews =
new ArrayList<>(cachedWorldStatesByHash.values());
return cachedDiffBasedWorldViews.stream()
return cachedPathBasedWorldViews.stream()
.sorted(
Comparator.comparingLong(
view -> Math.abs(blockHeader.getNumber() - view.getBlockNumber())))
.map(DiffBasedCachedWorldView::getWorldStateStorage)
.map(PathBasedCachedWorldView::getWorldStateStorage)
.findFirst();
})
.map(
@@ -197,7 +197,7 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
archive, createLayeredKeyValueStorage(storage), evmConfiguration));
}
public Optional<DiffBasedWorldState> getHeadWorldState(
public Optional<PathBasedWorldState> getHeadWorldState(
final Function<Hash, Optional<BlockHeader>> hashBlockHeaderFunction) {
LOG.atDebug().setMessage("getting head worldstate").log();
@@ -242,13 +242,13 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
* @param rootHash rootHash to supply worldstate storage for
* @return Optional worldstate storage
*/
public synchronized Optional<DiffBasedWorldStateKeyValueStorage> getStorageByRootHash(
public synchronized Optional<PathBasedWorldStateKeyValueStorage> getStorageByRootHash(
final Hash rootHash) {
return Optional.ofNullable(stateRootToBlockHeaderCache.getIfPresent(rootHash))
.flatMap(
header ->
Optional.ofNullable(cachedWorldStatesByHash.get(header.getHash()))
.map(DiffBasedCachedWorldView::getWorldStateStorage)
.map(PathBasedCachedWorldView::getWorldStateStorage)
.or(
() -> {
// if not cached already, maybe fetch and cache this worldstate
@@ -287,14 +287,14 @@ public abstract class DiffBasedCachedWorldStorageManager implements StorageSubsc
this.cachedWorldStatesByHash.clear();
}
public abstract DiffBasedWorldState createWorldState(
final DiffBasedWorldStateProvider archive,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
public abstract PathBasedWorldState createWorldState(
final PathBasedWorldStateProvider archive,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final EvmConfiguration evmConfiguration);
public abstract DiffBasedWorldStateKeyValueStorage createLayeredKeyValueStorage(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage);
public abstract PathBasedWorldStateKeyValueStorage createLayeredKeyValueStorage(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage);
public abstract DiffBasedWorldStateKeyValueStorage createSnapshotKeyValueStorage(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage);
public abstract PathBasedWorldStateKeyValueStorage createSnapshotKeyValueStorage(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage);
}

22
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/cache/DiffBasedCachedWorldView.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/cache/PathBasedCachedWorldView.java vendored
View File

@@ -12,30 +12,30 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.cache;
package org.hyperledger.besu.ethereum.trie.pathbased.common.cache;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DiffBasedCachedWorldView implements StorageSubscriber {
private DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
public class PathBasedCachedWorldView implements StorageSubscriber {
private PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
private final BlockHeader blockHeader;
private long worldViewSubscriberId;
private static final Logger LOG = LoggerFactory.getLogger(DiffBasedCachedWorldView.class);
private static final Logger LOG = LoggerFactory.getLogger(PathBasedCachedWorldView.class);
public DiffBasedCachedWorldView(
final BlockHeader blockHeader, final DiffBasedWorldStateKeyValueStorage worldView) {
public PathBasedCachedWorldView(
final BlockHeader blockHeader, final PathBasedWorldStateKeyValueStorage worldView) {
this.blockHeader = blockHeader;
this.worldStateKeyValueStorage = worldView;
this.worldViewSubscriberId = worldStateKeyValueStorage.subscribe(this);
}
public DiffBasedWorldStateKeyValueStorage getWorldStateStorage() {
public PathBasedWorldStateKeyValueStorage getWorldStateStorage() {
return worldStateKeyValueStorage;
}
@@ -57,10 +57,10 @@ public class DiffBasedCachedWorldView implements StorageSubscriber {
}
public synchronized void updateWorldStateStorage(
final DiffBasedWorldStateKeyValueStorage newWorldStateStorage) {
final PathBasedWorldStateKeyValueStorage newWorldStateStorage) {
long newSubscriberId = newWorldStateStorage.subscribe(this);
this.worldStateKeyValueStorage.unSubscribe(this.worldViewSubscriberId);
final DiffBasedWorldStateKeyValueStorage oldWorldStateStorage = this.worldStateKeyValueStorage;
final PathBasedWorldStateKeyValueStorage oldWorldStateStorage = this.worldStateKeyValueStorage;
this.worldStateKeyValueStorage = newWorldStateStorage;
this.worldViewSubscriberId = newSubscriberId;
try {

62
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/provider/DiffBasedWorldStateProvider.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/provider/PathBasedWorldStateProvider.java
View File

@@ -12,9 +12,9 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.provider;
package org.hyperledger.besu.ethereum.trie.pathbased.common.provider;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams.withBlockHeaderAndNoUpdateNodeHead;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
@@ -24,12 +24,12 @@ import org.hyperledger.besu.ethereum.core.MutableWorldState;
import org.hyperledger.besu.ethereum.proof.WorldStateProof;
import org.hyperledger.besu.ethereum.proof.WorldStateProofProvider;
import org.hyperledger.besu.ethereum.trie.MerkleTrieException;
import org.hyperledger.besu.ethereum.trie.diffbased.common.cache.DiffBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.cache.PathBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.ethereum.worldstate.WorldStateStorageCoordinator;
import org.hyperledger.besu.evm.worldstate.WorldState;
@@ -46,21 +46,21 @@ import org.apache.tuweni.units.bigints.UInt256;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
public abstract class PathBasedWorldStateProvider implements WorldStateArchive {
private static final Logger LOG = LoggerFactory.getLogger(DiffBasedWorldStateProvider.class);
private static final Logger LOG = LoggerFactory.getLogger(PathBasedWorldStateProvider.class);
protected final Blockchain blockchain;
protected final TrieLogManager trieLogManager;
protected DiffBasedCachedWorldStorageManager cachedWorldStorageManager;
protected DiffBasedWorldState headWorldState;
protected final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
protected PathBasedCachedWorldStorageManager cachedWorldStorageManager;
protected PathBasedWorldState headWorldState;
protected final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
// Configuration that will be shared by all instances of world state at their creation
protected final WorldStateConfig worldStateConfig;
public DiffBasedWorldStateProvider(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
public PathBasedWorldStateProvider(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final Blockchain blockchain,
final Optional<Long> maxLayersToLoad,
final ServiceManager pluginContext) {
@@ -70,12 +70,12 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
new TrieLogManager(
blockchain,
worldStateKeyValueStorage,
maxLayersToLoad.orElse(DiffBasedCachedWorldStorageManager.RETAINED_LAYERS),
maxLayersToLoad.orElse(PathBasedCachedWorldStorageManager.RETAINED_LAYERS),
pluginContext));
}
public DiffBasedWorldStateProvider(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
public PathBasedWorldStateProvider(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final Blockchain blockchain,
final TrieLogManager trieLogManager) {
@@ -87,11 +87,11 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
}
protected void provideCachedWorldStorageManager(
final DiffBasedCachedWorldStorageManager cachedWorldStorageManager) {
final PathBasedCachedWorldStorageManager cachedWorldStorageManager) {
this.cachedWorldStorageManager = cachedWorldStorageManager;
}
protected void loadHeadWorldState(final DiffBasedWorldState headWorldState) {
protected void loadHeadWorldState(final PathBasedWorldState headWorldState) {
this.headWorldState = headWorldState;
blockchain
.getBlockHeader(headWorldState.getWorldStateBlockHash())
@@ -233,7 +233,7 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
}
private Optional<MutableWorldState> rollFullWorldStateToBlockHash(
final DiffBasedWorldState mutableState, final Hash blockHash) {
final PathBasedWorldState mutableState, final Hash blockHash) {
if (blockHash.equals(mutableState.blockHash())) {
return Optional.of(mutableState);
} else {
@@ -282,19 +282,19 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
}
// attempt the state rolling
final DiffBasedWorldStateUpdateAccumulator<?> diffBasedUpdater =
(DiffBasedWorldStateUpdateAccumulator<?>) mutableState.updater();
final PathBasedWorldStateUpdateAccumulator<?> pathBasedUpdater =
(PathBasedWorldStateUpdateAccumulator<?>) mutableState.updater();
try {
for (final TrieLog rollBack : rollBacks) {
LOG.debug("Attempting Rollback of {}", rollBack.getBlockHash());
diffBasedUpdater.rollBack(rollBack);
pathBasedUpdater.rollBack(rollBack);
}
for (int i = rollForwards.size() - 1; i >= 0; i--) {
final var forward = rollForwards.get(i);
LOG.debug("Attempting Rollforward of {}", rollForwards.get(i).getBlockHash());
diffBasedUpdater.rollForward(forward);
pathBasedUpdater.rollForward(forward);
}
diffBasedUpdater.commit();
pathBasedUpdater.commit();
mutableState.persist(blockchain.getBlockHeader(blockHash).get());
@@ -308,7 +308,7 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
throw re;
} catch (final Exception e) {
// if we fail we must clean up the updater
diffBasedUpdater.reset();
pathBasedUpdater.reset();
LOG.atDebug()
.setMessage("State rolling failed on {} for block hash {}")
.addArgument(mutableState.getWorldStateStorage().getClass().getSimpleName())
@@ -334,7 +334,7 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
return worldStateConfig;
}
public DiffBasedWorldStateKeyValueStorage getWorldStateKeyValueStorage() {
public PathBasedWorldStateKeyValueStorage getWorldStateKeyValueStorage() {
return worldStateKeyValueStorage;
}
@@ -342,7 +342,7 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
return trieLogManager;
}
public DiffBasedCachedWorldStorageManager getCachedWorldStorageManager() {
public PathBasedCachedWorldStorageManager getCachedWorldStorageManager() {
return cachedWorldStorageManager;
}
@@ -360,8 +360,8 @@ public abstract class DiffBasedWorldStateProvider implements WorldStateArchive {
final Address accountAddress,
final List<UInt256> accountStorageKeys,
final Function<Optional<WorldStateProof>, ? extends Optional<U>> mapper) {
try (DiffBasedWorldState ws =
(DiffBasedWorldState)
try (PathBasedWorldState ws =
(PathBasedWorldState)
getWorldState(withBlockHeaderAndNoUpdateNodeHead(blockHeader)).orElse(null)) {
if (ws != null) {
final WorldStateProofProvider worldStateProofProvider =

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/provider/WorldStateQueryParams.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/provider/WorldStateQueryParams.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.provider;
package org.hyperledger.besu.ethereum.trie.pathbased.common.provider;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.BlockHeader;

8
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedLayeredWorldStateKeyValueStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/PathBasedLayeredWorldStateKeyValueStorage.java
View File

@@ -12,10 +12,10 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage;
public interface DiffBasedLayeredWorldStateKeyValueStorage
extends DiffBasedSnapshotWorldStateKeyValueStorage {
public interface PathBasedLayeredWorldStateKeyValueStorage
extends PathBasedSnapshotWorldStateKeyValueStorage {
DiffBasedWorldStateKeyValueStorage clone();
PathBasedWorldStateKeyValueStorage clone();
}

6
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedSnapshotWorldStateKeyValueStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/PathBasedSnapshotWorldStateKeyValueStorage.java
View File

@@ -12,9 +12,9 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage;
public interface DiffBasedSnapshotWorldStateKeyValueStorage {
public interface PathBasedSnapshotWorldStateKeyValueStorage {
DiffBasedWorldStateKeyValueStorage getParentWorldStateStorage();
PathBasedWorldStateKeyValueStorage getParentWorldStateStorage();
}

16
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/DiffBasedWorldStateKeyValueStorage.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/PathBasedWorldStateKeyValueStorage.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_INFO_STATE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.ACCOUNT_STORAGE_STORAGE;
@@ -22,8 +22,8 @@ import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIden
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.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat.FlatDbStrategy;
import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
@@ -47,10 +47,10 @@ import org.apache.tuweni.bytes.Bytes32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class DiffBasedWorldStateKeyValueStorage
public abstract class PathBasedWorldStateKeyValueStorage
implements WorldStateKeyValueStorage, AutoCloseable {
private static final Logger LOG =
LoggerFactory.getLogger(DiffBasedWorldStateKeyValueStorage.class);
LoggerFactory.getLogger(PathBasedWorldStateKeyValueStorage.class);
// 0x776f726c64526f6f74
public static final byte[] WORLD_ROOT_HASH_KEY = "worldRoot".getBytes(StandardCharsets.UTF_8);
@@ -66,7 +66,7 @@ public abstract class DiffBasedWorldStateKeyValueStorage
protected final SegmentedKeyValueStorage composedWorldStateStorage;
protected final KeyValueStorage trieLogStorage;
public DiffBasedWorldStateKeyValueStorage(final StorageProvider provider) {
public PathBasedWorldStateKeyValueStorage(final StorageProvider provider) {
this.composedWorldStateStorage =
provider.getStorageBySegmentIdentifiers(
List.of(
@@ -75,7 +75,7 @@ public abstract class DiffBasedWorldStateKeyValueStorage
provider.getStorageBySegmentIdentifier(KeyValueSegmentIdentifier.TRIE_LOG_STORAGE);
}
public DiffBasedWorldStateKeyValueStorage(
public PathBasedWorldStateKeyValueStorage(
final SegmentedKeyValueStorage composedWorldStateStorage,
final KeyValueStorage trieLogStorage) {
this.composedWorldStateStorage = composedWorldStateStorage;
@@ -240,7 +240,7 @@ public abstract class DiffBasedWorldStateKeyValueStorage
public interface Updater extends WorldStateKeyValueStorage.Updater {
DiffBasedWorldStateKeyValueStorage.Updater saveWorldState(
PathBasedWorldStateKeyValueStorage.Updater saveWorldState(
final Bytes blockHash, final Bytes32 nodeHash, final Bytes node);
SegmentedKeyValueStorageTransaction getWorldStateTransaction();

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/flat/AccountHashCodeStorageStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/flat/AccountHashCodeStorageStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.CODE_STORAGE;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/flat/CodeHashCodeStorageStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/flat/CodeHashCodeStorageStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.CODE_STORAGE;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/flat/CodeStorageStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/flat/CodeStorageStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.plugin.services.storage.SegmentedKeyValueStorage;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/flat/FlatDbStrategy.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/flat/FlatDbStrategy.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.metrics.BesuMetricCategory;

6
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/storage/flat/FlatDbStrategyProvider.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/storage/flat/FlatDbStrategyProvider.java
View File

@@ -12,11 +12,11 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.storage.flat;
package org.hyperledger.besu.ethereum.trie.pathbased.common.storage.flat;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.CODE_STORAGE;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.TRIE_BRANCH_STORAGE;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage.WORLD_ROOT_HASH_KEY;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage.WORLD_ROOT_HASH_KEY;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.FlatDbMode;
@@ -66,7 +66,7 @@ public abstract class FlatDbStrategyProvider {
final SegmentedKeyValueStorage composedWorldStateStorage) {
final boolean configCodeUsingHash =
dataStorageConfiguration
.getDiffBasedSubStorageConfiguration()
.getPathBasedExtraStorageConfiguration()
.getUnstable()
.getCodeStoredByCodeHashEnabled();
boolean codeUsingCodeByHash =

10
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/NoOpTrieLogManager.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/trielog/NoOpTrieLogManager.java
View File

@@ -12,12 +12,12 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.common.trielog;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
import java.util.Optional;
@@ -30,10 +30,10 @@ public class NoOpTrieLogManager extends TrieLogManager {
@Override
public synchronized void saveTrieLog(
final DiffBasedWorldStateUpdateAccumulator<?> localUpdater,
final PathBasedWorldStateUpdateAccumulator<?> localUpdater,
final Hash forWorldStateRootHash,
final BlockHeader forBlockHeader,
final DiffBasedWorldState forWorldState) {
final PathBasedWorldState forWorldState) {
// notify trie log added observers, synchronously
TrieLog trieLog = trieLogFactory.create(localUpdater, forBlockHeader);
trieLogObservers.forEach(o -> o.onTrieLogAdded(new TrieLogAddedEvent(trieLog)));

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogAddedEvent.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/trielog/TrieLogAddedEvent.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.common.trielog;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
import org.hyperledger.besu.plugin.services.trielogs.TrieLogEvent;

50
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogLayer.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/trielog/TrieLogLayer.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.common.trielog;
import static com.google.common.base.Preconditions.checkState;
@@ -20,7 +20,7 @@ import org.hyperledger.besu.datatypes.AccountValue;
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.common.DiffBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
import java.util.HashMap;
@@ -47,21 +47,21 @@ public class TrieLogLayer implements TrieLog {
protected Hash blockHash;
protected Optional<Long> blockNumber = Optional.empty();
Map<Address, DiffBasedValue<AccountValue>> getAccounts() {
Map<Address, PathBasedValue<AccountValue>> getAccounts() {
return accounts;
}
Map<Address, DiffBasedValue<Bytes>> getCode() {
Map<Address, PathBasedValue<Bytes>> getCode() {
return code;
}
Map<Address, Map<StorageSlotKey, DiffBasedValue<UInt256>>> getStorage() {
Map<Address, Map<StorageSlotKey, PathBasedValue<UInt256>>> getStorage() {
return storage;
}
protected final Map<Address, DiffBasedValue<AccountValue>> accounts;
protected final Map<Address, DiffBasedValue<Bytes>> code;
protected final Map<Address, Map<StorageSlotKey, DiffBasedValue<UInt256>>> storage;
protected final Map<Address, PathBasedValue<AccountValue>> accounts;
protected final Map<Address, PathBasedValue<Bytes>> code;
protected final Map<Address, Map<StorageSlotKey, PathBasedValue<UInt256>>> storage;
protected boolean frozen = false;
public TrieLogLayer() {
@@ -102,14 +102,14 @@ public class TrieLogLayer implements TrieLog {
public TrieLogLayer addAccountChange(
final Address address, final AccountValue oldValue, final AccountValue newValue) {
checkState(!frozen, "Layer is Frozen");
accounts.put(address, new DiffBasedValue<>(oldValue, newValue));
accounts.put(address, new PathBasedValue<>(oldValue, newValue));
return this;
}
public TrieLogLayer addCodeChange(
final Address address, final Bytes oldValue, final Bytes newValue, final Hash blockHash) {
checkState(!frozen, "Layer is Frozen");
code.put(address, new DiffBasedValue<>(oldValue, newValue, newValue == null));
code.put(address, new PathBasedValue<>(oldValue, newValue, newValue == null));
return this;
}
@@ -121,22 +121,22 @@ public class TrieLogLayer implements TrieLog {
checkState(!frozen, "Layer is Frozen");
storage
.computeIfAbsent(address, a -> new TreeMap<>())
.put(slot, new DiffBasedValue<>(oldValue, newValue));
.put(slot, new PathBasedValue<>(oldValue, newValue));
return this;
}
@Override
public Map<Address, DiffBasedValue<AccountValue>> getAccountChanges() {
public Map<Address, PathBasedValue<AccountValue>> getAccountChanges() {
return accounts;
}
@Override
public Map<Address, DiffBasedValue<Bytes>> getCodeChanges() {
public Map<Address, PathBasedValue<Bytes>> getCodeChanges() {
return code;
}
@Override
public Map<Address, Map<StorageSlotKey, DiffBasedValue<UInt256>>> getStorageChanges() {
public Map<Address, Map<StorageSlotKey, PathBasedValue<UInt256>>> getStorageChanges() {
return storage;
}
@@ -145,18 +145,18 @@ public class TrieLogLayer implements TrieLog {
}
@Override
public Map<StorageSlotKey, DiffBasedValue<UInt256>> getStorageChanges(final Address address) {
public Map<StorageSlotKey, PathBasedValue<UInt256>> getStorageChanges(final Address address) {
return storage.getOrDefault(address, Map.of());
}
@Override
public Optional<Bytes> getPriorCode(final Address address) {
return Optional.ofNullable(code.get(address)).map(DiffBasedValue::getPrior);
return Optional.ofNullable(code.get(address)).map(PathBasedValue::getPrior);
}
@Override
public Optional<Bytes> getCode(final Address address) {
return Optional.ofNullable(code.get(address)).map(DiffBasedValue::getUpdated);
return Optional.ofNullable(code.get(address)).map(PathBasedValue::getUpdated);
}
@Override
@@ -164,7 +164,7 @@ public class TrieLogLayer implements TrieLog {
final Address address, final StorageSlotKey storageSlotKey) {
return Optional.ofNullable(storage.get(address))
.map(i -> i.get(storageSlotKey))
.map(DiffBasedValue::getPrior);
.map(PathBasedValue::getPrior);
}
@Override
@@ -172,24 +172,24 @@ public class TrieLogLayer implements TrieLog {
final Address address, final StorageSlotKey storageSlotKey) {
return Optional.ofNullable(storage.get(address))
.map(i -> i.get(storageSlotKey))
.map(DiffBasedValue::getUpdated);
.map(PathBasedValue::getUpdated);
}
@Override
public Optional<AccountValue> getPriorAccount(final Address address) {
return Optional.ofNullable(accounts.get(address)).map(DiffBasedValue::getPrior);
return Optional.ofNullable(accounts.get(address)).map(PathBasedValue::getPrior);
}
@Override
public Optional<AccountValue> getAccount(final Address address) {
return Optional.ofNullable(accounts.get(address)).map(DiffBasedValue::getUpdated);
return Optional.ofNullable(accounts.get(address)).map(PathBasedValue::getUpdated);
}
public String dump() {
final StringBuilder sb = new StringBuilder();
sb.append("TrieLog{" + "blockHash=").append(blockHash).append(frozen).append('}');
sb.append("accounts\n");
for (final Map.Entry<Address, DiffBasedValue<AccountValue>> account : accounts.entrySet()) {
for (final Map.Entry<Address, PathBasedValue<AccountValue>> account : accounts.entrySet()) {
sb.append(" : ").append(account.getKey()).append("\n");
if (Objects.equals(account.getValue().getPrior(), account.getValue().getUpdated())) {
sb.append(" = ").append(account.getValue().getUpdated()).append("\n");
@@ -199,7 +199,7 @@ public class TrieLogLayer implements TrieLog {
}
}
sb.append("code").append("\n");
for (final Map.Entry<Address, DiffBasedValue<Bytes>> code : code.entrySet()) {
for (final Map.Entry<Address, PathBasedValue<Bytes>> code : code.entrySet()) {
sb.append(" : ").append(code.getKey()).append("\n");
if (Objects.equals(code.getValue().getPrior(), code.getValue().getUpdated())) {
sb.append(" = ").append(code.getValue().getPrior()).append("\n");
@@ -209,10 +209,10 @@ public class TrieLogLayer implements TrieLog {
}
}
sb.append("Storage").append("\n");
for (final Map.Entry<Address, Map<StorageSlotKey, DiffBasedValue<UInt256>>> storage :
for (final Map.Entry<Address, Map<StorageSlotKey, PathBasedValue<UInt256>>> storage :
storage.entrySet()) {
sb.append(" : ").append(storage.getKey()).append("\n");
for (final Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>> slot :
for (final Map.Entry<StorageSlotKey, PathBasedValue<UInt256>> slot :
storage.getValue().entrySet()) {
final UInt256 originalValue = slot.getValue().getPrior();
final UInt256 updatedValue = slot.getValue().getUpdated();

26
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogManager.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/trielog/TrieLogManager.java
View File

@@ -12,15 +12,15 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.common.trielog;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.trielog.TrieLogFactoryImpl;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.trielog.TrieLogFactoryImpl;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.plugin.ServiceManager;
import org.hyperledger.besu.plugin.services.TrieLogService;
import org.hyperledger.besu.plugin.services.trielogs.TrieLog;
@@ -42,7 +42,7 @@ public class TrieLogManager {
private static final Logger LOG = LoggerFactory.getLogger(TrieLogManager.class);
public static final long LOG_RANGE_LIMIT = 1000; // restrict trielog range queries to 1k logs
protected final Blockchain blockchain;
protected final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage;
protected final PathBasedWorldStateKeyValueStorage rootWorldStateStorage;
protected final long maxLayersToLoad;
protected final Subscribers<TrieLogEvent.TrieLogObserver> trieLogObservers = Subscribers.create();
@@ -51,7 +51,7 @@ public class TrieLogManager {
public TrieLogManager(
final Blockchain blockchain,
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final long maxLayersToLoad,
final ServiceManager pluginContext) {
this.blockchain = blockchain;
@@ -61,15 +61,15 @@ public class TrieLogManager {
}
public synchronized void saveTrieLog(
final DiffBasedWorldStateUpdateAccumulator<?> localUpdater,
final PathBasedWorldStateUpdateAccumulator<?> localUpdater,
final Hash forWorldStateRootHash,
final BlockHeader forBlockHeader,
final DiffBasedWorldState forWorldState) {
final PathBasedWorldState forWorldState) {
// do not overwrite a trielog layer that already exists in the database.
// if it's only in memory we need to save it
// for example, in case of reorg we don't replace a trielog layer
if (rootWorldStateStorage.getTrieLog(forBlockHeader.getHash()).isEmpty()) {
final DiffBasedWorldStateKeyValueStorage.Updater stateUpdater =
final PathBasedWorldStateKeyValueStorage.Updater stateUpdater =
forWorldState.getWorldStateStorage().updater();
boolean success = false;
try {
@@ -91,7 +91,7 @@ public class TrieLogManager {
}
private TrieLog prepareTrieLog(
final BlockHeader blockHeader, final DiffBasedWorldStateUpdateAccumulator<?> localUpdater) {
final BlockHeader blockHeader, final PathBasedWorldStateUpdateAccumulator<?> localUpdater) {
LOG.atDebug()
.setMessage("Adding layered world state for {}")
.addArgument(blockHeader::toLogString)
@@ -105,7 +105,7 @@ public class TrieLogManager {
final BlockHeader blockHeader,
final Hash worldStateRootHash,
final TrieLog trieLog,
final DiffBasedWorldStateKeyValueStorage.Updater stateUpdater) {
final PathBasedWorldStateKeyValueStorage.Updater stateUpdater) {
LOG.atDebug()
.setMessage("Persisting trie log for block hash {} and world state root {}")
.addArgument(blockHeader::toLogString)
@@ -175,7 +175,7 @@ public class TrieLogManager {
@Override
public void saveRawTrieLogLayer(
final Hash blockHash, final long blockNumber, final Bytes trieLog) {
final DiffBasedWorldStateKeyValueStorage.Updater updater = rootWorldStateStorage.updater();
final PathBasedWorldStateKeyValueStorage.Updater updater = rootWorldStateStorage.updater();
updater
.getTrieLogStorageTransaction()
.put(blockHash.toArrayUnsafe(), trieLog.toArrayUnsafe());

8
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/trielog/TrieLogPruner.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/trielog/TrieLogPruner.java
View File

@@ -12,13 +12,13 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.trielog;
package org.hyperledger.besu.ethereum.trie.pathbased.common.trielog;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.chain.Blockchain;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.metrics.BesuMetricCategory;
import org.hyperledger.besu.plugin.services.MetricsSystem;
import org.hyperledger.besu.plugin.services.metrics.Counter;
@@ -51,7 +51,7 @@ public class TrieLogPruner implements TrieLogEvent.TrieLogObserver {
private final int pruningLimit;
private final int loadingLimit;
private final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage;
private final PathBasedWorldStateKeyValueStorage rootWorldStateStorage;
private final Blockchain blockchain;
private final Consumer<Runnable> executeAsync;
private final long numBlocksToRetain;
@@ -64,7 +64,7 @@ public class TrieLogPruner implements TrieLogEvent.TrieLogObserver {
TreeMultimap.create(Comparator.reverseOrder(), Comparator.naturalOrder());
public TrieLogPruner(
final DiffBasedWorldStateKeyValueStorage rootWorldStateStorage,
final PathBasedWorldStateKeyValueStorage rootWorldStateStorage,
final Blockchain blockchain,
final Consumer<Runnable> executeAsync,
final long numBlocksToRetain,

60
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldState.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/PathBasedWorldState.java
View File

@@ -12,24 +12,24 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview;
import static org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueSegmentIdentifier.TRIE_BRANCH_STORAGE;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage.WORLD_BLOCK_HASH_KEY;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage.WORLD_ROOT_HASH_KEY;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage.WORLD_BLOCK_HASH_KEY;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage.WORLD_ROOT_HASH_KEY;
import org.hyperledger.besu.datatypes.Address;
import org.hyperledger.besu.datatypes.Hash;
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.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.diffbased.common.cache.DiffBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedSnapshotWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.DiffBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.trie.pathbased.common.StorageSubscriber;
import org.hyperledger.besu.ethereum.trie.pathbased.common.cache.PathBasedCachedWorldStorageManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedLayeredWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedSnapshotWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.trielog.TrieLogManager;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.PathBasedWorldStateUpdateAccumulator;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
import org.hyperledger.besu.evm.account.Account;
import org.hyperledger.besu.evm.worldstate.WorldUpdater;
@@ -48,15 +48,15 @@ import org.apache.tuweni.units.bigints.UInt256;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class DiffBasedWorldState
implements MutableWorldState, DiffBasedWorldView, StorageSubscriber {
public abstract class PathBasedWorldState
implements MutableWorldState, PathBasedWorldView, StorageSubscriber {
private static final Logger LOG = LoggerFactory.getLogger(DiffBasedWorldState.class);
private static final Logger LOG = LoggerFactory.getLogger(PathBasedWorldState.class);
protected DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
protected final DiffBasedCachedWorldStorageManager cachedWorldStorageManager;
protected PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage;
protected final PathBasedCachedWorldStorageManager cachedWorldStorageManager;
protected final TrieLogManager trieLogManager;
protected DiffBasedWorldStateUpdateAccumulator<?> accumulator;
protected PathBasedWorldStateUpdateAccumulator<?> accumulator;
protected Hash worldStateRootHash;
protected Hash worldStateBlockHash;
@@ -74,9 +74,9 @@ public abstract class DiffBasedWorldState
*/
protected boolean isStorageFrozen;
protected DiffBasedWorldState(
final DiffBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final DiffBasedCachedWorldStorageManager cachedWorldStorageManager,
protected PathBasedWorldState(
final PathBasedWorldStateKeyValueStorage worldStateKeyValueStorage,
final PathBasedCachedWorldStorageManager cachedWorldStorageManager,
final TrieLogManager trieLogManager,
final WorldStateConfig worldStateConfig) {
this.worldStateKeyValueStorage = worldStateKeyValueStorage;
@@ -99,7 +99,7 @@ public abstract class DiffBasedWorldState
*
* @param accumulator accumulator to use.
*/
public void setAccumulator(final DiffBasedWorldStateUpdateAccumulator<?> accumulator) {
public void setAccumulator(final PathBasedWorldStateUpdateAccumulator<?> accumulator) {
this.accumulator = accumulator;
}
@@ -136,7 +136,7 @@ public abstract class DiffBasedWorldState
private boolean isModifyingHeadWorldState(
final WorldStateKeyValueStorage worldStateKeyValueStorage) {
return !(worldStateKeyValueStorage instanceof DiffBasedSnapshotWorldStateKeyValueStorage);
return !(worldStateKeyValueStorage instanceof PathBasedSnapshotWorldStateKeyValueStorage);
}
/**
@@ -150,17 +150,17 @@ public abstract class DiffBasedWorldState
}
@Override
public DiffBasedWorldStateKeyValueStorage getWorldStateStorage() {
public PathBasedWorldStateKeyValueStorage getWorldStateStorage() {
return worldStateKeyValueStorage;
}
public DiffBasedWorldStateUpdateAccumulator<?> getAccumulator() {
public PathBasedWorldStateUpdateAccumulator<?> getAccumulator() {
return accumulator;
}
protected Hash unsafeRootHashUpdate(
final BlockHeader blockHeader,
final DiffBasedWorldStateKeyValueStorage.Updater stateUpdater) {
final PathBasedWorldStateKeyValueStorage.Updater stateUpdater) {
// calling calculateRootHash in order to update the state
calculateRootHash(isStorageFrozen ? Optional.empty() : Optional.of(stateUpdater), accumulator);
return blockHeader.getStateRoot();
@@ -174,11 +174,11 @@ public abstract class DiffBasedWorldState
.addArgument(maybeBlockHeader)
.log();
final DiffBasedWorldStateUpdateAccumulator<?> localCopy = accumulator.copy();
final PathBasedWorldStateUpdateAccumulator<?> localCopy = accumulator.copy();
boolean success = false;
final DiffBasedWorldStateKeyValueStorage.Updater stateUpdater =
final PathBasedWorldStateKeyValueStorage.Updater stateUpdater =
worldStateKeyValueStorage.updater();
Runnable saveTrieLog = () -> {};
@@ -340,8 +340,8 @@ public abstract class DiffBasedWorldState
private void closeFrozenStorage() {
try {
final DiffBasedLayeredWorldStateKeyValueStorage worldStateLayerStorage =
(DiffBasedLayeredWorldStateKeyValueStorage) worldStateKeyValueStorage;
final PathBasedLayeredWorldStateKeyValueStorage worldStateLayerStorage =
(PathBasedLayeredWorldStateKeyValueStorage) worldStateKeyValueStorage;
if (!isModifyingHeadWorldState(worldStateLayerStorage.getParentWorldStateStorage())) {
worldStateLayerStorage.getParentWorldStateStorage().close();
}
@@ -383,8 +383,8 @@ public abstract class DiffBasedWorldState
public abstract Optional<Bytes> getCode(@Nonnull final Address address, final Hash codeHash);
protected abstract Hash calculateRootHash(
final Optional<DiffBasedWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final DiffBasedWorldStateUpdateAccumulator<?> worldStateUpdater);
final Optional<PathBasedWorldStateKeyValueStorage.Updater> maybeStateUpdater,
final PathBasedWorldStateUpdateAccumulator<?> worldStateUpdater);
protected abstract Hash getEmptyTrieHash();
}

8
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/DiffBasedWorldView.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/PathBasedWorldView.java
View File

@@ -12,13 +12,13 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview;
import org.hyperledger.besu.datatypes.Address;
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.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.evm.worldstate.WorldUpdater;
import org.hyperledger.besu.evm.worldstate.WorldView;
@@ -29,7 +29,7 @@ import org.apache.tuweni.bytes.Bytes;
import org.apache.tuweni.bytes.Bytes32;
import org.apache.tuweni.units.bigints.UInt256;
public interface DiffBasedWorldView extends WorldView {
public interface PathBasedWorldView extends WorldView {
Optional<Bytes> getCode(Address address, final Hash codeHash);
@@ -57,7 +57,7 @@ public interface DiffBasedWorldView extends WorldView {
boolean isModifyingHeadWorldState();
DiffBasedWorldStateKeyValueStorage getWorldStateStorage();
PathBasedWorldStateKeyValueStorage getWorldStateStorage();
WorldUpdater updater();
}

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/WorldStateConfig.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/WorldStateConfig.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview;
/** WorldStateConfig encapsulates the shared configuration parameters for the world state. */
public class WorldStateConfig {

262
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/DiffBasedWorldStateUpdateAccumulator.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/accumulator/PathBasedWorldStateUpdateAccumulator.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator;
import org.hyperledger.besu.datatypes.AccountValue;
import org.hyperledger.besu.datatypes.Address;
@@ -21,14 +21,14 @@ import org.hyperledger.besu.datatypes.StorageSlotKey;
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.common.DiffBasedAccount;
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue;
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldState;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.AccountConsumingMap;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.Consumer;
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.StorageConsumingMap;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedAccount;
import org.hyperledger.besu.ethereum.trie.pathbased.common.PathBasedValue;
import org.hyperledger.besu.ethereum.trie.pathbased.common.storage.PathBasedWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.PathBasedWorldView;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.AccountConsumingMap;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.Consumer;
import org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload.StorageConsumingMap;
import org.hyperledger.besu.evm.account.Account;
import org.hyperledger.besu.evm.account.MutableAccount;
import org.hyperledger.besu.evm.internal.EvmConfiguration;
@@ -55,31 +55,31 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@SuppressWarnings("unchecked")
public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffBasedAccount>
extends AbstractWorldUpdater<DiffBasedWorldView, ACCOUNT>
implements DiffBasedWorldView, TrieLogAccumulator {
public abstract class PathBasedWorldStateUpdateAccumulator<ACCOUNT extends PathBasedAccount>
extends AbstractWorldUpdater<PathBasedWorldView, ACCOUNT>
implements PathBasedWorldView, TrieLogAccumulator {
private static final Logger LOG =
LoggerFactory.getLogger(DiffBasedWorldStateUpdateAccumulator.class);
protected final Consumer<DiffBasedValue<ACCOUNT>> accountPreloader;
LoggerFactory.getLogger(PathBasedWorldStateUpdateAccumulator.class);
protected final Consumer<PathBasedValue<ACCOUNT>> accountPreloader;
protected final Consumer<StorageSlotKey> storagePreloader;
private final AccountConsumingMap<DiffBasedValue<ACCOUNT>> accountsToUpdate;
private final Map<Address, DiffBasedValue<Bytes>> codeToUpdate = new ConcurrentHashMap<>();
private final AccountConsumingMap<PathBasedValue<ACCOUNT>> accountsToUpdate;
private final Map<Address, PathBasedValue<Bytes>> codeToUpdate = new ConcurrentHashMap<>();
private final Set<Address> storageToClear = Collections.synchronizedSet(new HashSet<>());
protected final EvmConfiguration evmConfiguration;
// storage sub mapped by _hashed_ key. This is because in self_destruct calls we need to
// enumerate the old storage and delete it. Those are trie stored by hashed key by spec and the
// alternative was to keep a giant pre-image cache of the entire trie.
private final Map<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>>
private final Map<Address, StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>>>
storageToUpdate = new ConcurrentHashMap<>();
private final Map<UInt256, Hash> storageKeyHashLookup = new ConcurrentHashMap<>();
protected boolean isAccumulatorStateChanged;
public DiffBasedWorldStateUpdateAccumulator(
final DiffBasedWorldView world,
final Consumer<DiffBasedValue<ACCOUNT>> accountPreloader,
public PathBasedWorldStateUpdateAccumulator(
final PathBasedWorldView world,
final Consumer<PathBasedValue<ACCOUNT>> accountPreloader,
final Consumer<StorageSlotKey> storagePreloader,
final EvmConfiguration evmConfiguration) {
super(world, evmConfiguration);
@@ -90,7 +90,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
this.evmConfiguration = evmConfiguration;
}
public void cloneFromUpdater(final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
public void cloneFromUpdater(final PathBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
accountsToUpdate.putAll(source.getAccountsToUpdate());
codeToUpdate.putAll(source.codeToUpdate);
storageToClear.addAll(source.storageToClear);
@@ -111,52 +111,52 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
* @param source The source accumulator
*/
public void importStateChangesFromSource(
final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
final PathBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
source
.getAccountsToUpdate()
.forEach(
(address, diffBasedValue) -> {
(address, pathBasedValue) -> {
ACCOUNT copyPrior =
diffBasedValue.getPrior() != null
? copyAccount(diffBasedValue.getPrior(), this, false)
pathBasedValue.getPrior() != null
? copyAccount(pathBasedValue.getPrior(), this, false)
: null;
ACCOUNT copyUpdated =
diffBasedValue.getUpdated() != null
? copyAccount(diffBasedValue.getUpdated(), this, true)
pathBasedValue.getUpdated() != null
? copyAccount(pathBasedValue.getUpdated(), this, true)
: null;
accountsToUpdate.put(
address,
new DiffBasedValue<>(copyPrior, copyUpdated, diffBasedValue.isLastStepCleared()));
new PathBasedValue<>(copyPrior, copyUpdated, pathBasedValue.isLastStepCleared()));
});
source
.getCodeToUpdate()
.forEach(
(address, diffBasedValue) -> {
(address, pathBasedValue) -> {
codeToUpdate.put(
address,
new DiffBasedValue<>(
diffBasedValue.getPrior(),
diffBasedValue.getUpdated(),
diffBasedValue.isLastStepCleared()));
new PathBasedValue<>(
pathBasedValue.getPrior(),
pathBasedValue.getUpdated(),
pathBasedValue.isLastStepCleared()));
});
source
.getStorageToUpdate()
.forEach(
(address, slots) -> {
StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> storageConsumingMap =
StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> storageConsumingMap =
storageToUpdate.computeIfAbsent(
address,
k ->
new StorageConsumingMap<>(
address, new ConcurrentHashMap<>(), storagePreloader));
slots.forEach(
(storageSlotKey, uInt256DiffBasedValue) -> {
(storageSlotKey, uInt256PathBasedValue) -> {
storageConsumingMap.put(
storageSlotKey,
new DiffBasedValue<>(
uInt256DiffBasedValue.getPrior(),
uInt256DiffBasedValue.getUpdated(),
uInt256DiffBasedValue.isLastStepCleared()));
new PathBasedValue<>(
uInt256PathBasedValue.getPrior(),
uInt256PathBasedValue.getUpdated(),
uInt256PathBasedValue.isLastStepCleared()));
});
});
storageToClear.addAll(source.storageToClear);
@@ -177,53 +177,53 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
* @param source The source accumulator
*/
public void importPriorStateFromSource(
final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
final PathBasedWorldStateUpdateAccumulator<ACCOUNT> source) {
source
.getAccountsToUpdate()
.forEach(
(address, diffBasedValue) -> {
(address, pathBasedValue) -> {
ACCOUNT copyPrior =
diffBasedValue.getPrior() != null
? copyAccount(diffBasedValue.getPrior(), this, false)
pathBasedValue.getPrior() != null
? copyAccount(pathBasedValue.getPrior(), this, false)
: null;
ACCOUNT copyUpdated =
diffBasedValue.getPrior() != null
? copyAccount(diffBasedValue.getPrior(), this, true)
pathBasedValue.getPrior() != null
? copyAccount(pathBasedValue.getPrior(), this, true)
: null;
accountsToUpdate.putIfAbsent(address, new DiffBasedValue<>(copyPrior, copyUpdated));
accountsToUpdate.putIfAbsent(address, new PathBasedValue<>(copyPrior, copyUpdated));
});
source
.getCodeToUpdate()
.forEach(
(address, diffBasedValue) -> {
(address, pathBasedValue) -> {
codeToUpdate.putIfAbsent(
address,
new DiffBasedValue<>(diffBasedValue.getPrior(), diffBasedValue.getPrior()));
new PathBasedValue<>(pathBasedValue.getPrior(), pathBasedValue.getPrior()));
});
source
.getStorageToUpdate()
.forEach(
(address, slots) -> {
StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> storageConsumingMap =
StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> storageConsumingMap =
storageToUpdate.computeIfAbsent(
address,
k ->
new StorageConsumingMap<>(
address, new ConcurrentHashMap<>(), storagePreloader));
slots.forEach(
(storageSlotKey, uInt256DiffBasedValue) -> {
(storageSlotKey, uInt256PathBasedValue) -> {
storageConsumingMap.putIfAbsent(
storageSlotKey,
new DiffBasedValue<>(
uInt256DiffBasedValue.getPrior(), uInt256DiffBasedValue.getPrior()));
new PathBasedValue<>(
uInt256PathBasedValue.getPrior(), uInt256PathBasedValue.getPrior()));
});
});
storageKeyHashLookup.putAll(source.storageKeyHashLookup);
this.isAccumulatorStateChanged = true;
}
protected Consumer<DiffBasedValue<ACCOUNT>> getAccountPreloader() {
protected Consumer<PathBasedValue<ACCOUNT>> getAccountPreloader() {
return accountPreloader;
}
@@ -252,14 +252,14 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
@Override
public MutableAccount createAccount(final Address address, final long nonce, final Wei balance) {
DiffBasedValue<ACCOUNT> diffBasedValue = accountsToUpdate.get(address);
PathBasedValue<ACCOUNT> pathBasedValue = accountsToUpdate.get(address);
if (diffBasedValue == null) {
diffBasedValue = new DiffBasedValue<>(null, null);
accountsToUpdate.put(address, diffBasedValue);
} else if (diffBasedValue.getUpdated() != null) {
if (diffBasedValue.getUpdated().isEmpty()) {
return track(new UpdateTrackingAccount<>(diffBasedValue.getUpdated()));
if (pathBasedValue == null) {
pathBasedValue = new PathBasedValue<>(null, null);
accountsToUpdate.put(address, pathBasedValue);
} else if (pathBasedValue.getUpdated() != null) {
if (pathBasedValue.getUpdated().isEmpty()) {
return track(new UpdateTrackingAccount<>(pathBasedValue.getUpdated()));
} else {
throw new IllegalStateException("Cannot create an account when one already exists");
}
@@ -275,17 +275,17 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
Hash.EMPTY_TRIE_HASH,
Hash.EMPTY,
true);
diffBasedValue.setUpdated(newAccount);
pathBasedValue.setUpdated(newAccount);
return track(new UpdateTrackingAccount<>(newAccount));
}
@Override
public Map<Address, DiffBasedValue<ACCOUNT>> getAccountsToUpdate() {
public Map<Address, PathBasedValue<ACCOUNT>> getAccountsToUpdate() {
return accountsToUpdate;
}
@Override
public Map<Address, DiffBasedValue<Bytes>> getCodeToUpdate() {
public Map<Address, PathBasedValue<Bytes>> getCodeToUpdate() {
return codeToUpdate;
}
@@ -294,41 +294,41 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
}
@Override
public Map<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>>
public Map<Address, StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>>>
getStorageToUpdate() {
return storageToUpdate;
}
@Override
protected ACCOUNT getForMutation(final Address address) {
return loadAccount(address, DiffBasedValue::getUpdated);
return loadAccount(address, PathBasedValue::getUpdated);
}
protected ACCOUNT loadAccount(
final Address address, final Function<DiffBasedValue<ACCOUNT>, ACCOUNT> accountFunction) {
final Address address, final Function<PathBasedValue<ACCOUNT>, ACCOUNT> accountFunction) {
try {
final DiffBasedValue<ACCOUNT> diffBasedValue = accountsToUpdate.get(address);
if (diffBasedValue == null) {
final PathBasedValue<ACCOUNT> pathBasedValue = accountsToUpdate.get(address);
if (pathBasedValue == null) {
final Account account;
if (wrappedWorldView() instanceof DiffBasedWorldStateUpdateAccumulator) {
final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> worldStateUpdateAccumulator =
(DiffBasedWorldStateUpdateAccumulator<ACCOUNT>) wrappedWorldView();
if (wrappedWorldView() instanceof PathBasedWorldStateUpdateAccumulator) {
final PathBasedWorldStateUpdateAccumulator<ACCOUNT> worldStateUpdateAccumulator =
(PathBasedWorldStateUpdateAccumulator<ACCOUNT>) wrappedWorldView();
account = worldStateUpdateAccumulator.loadAccount(address, accountFunction);
} else {
account = wrappedWorldView().get(address);
}
if (account instanceof DiffBasedAccount diffBasedAccount) {
ACCOUNT mutableAccount = copyAccount((ACCOUNT) diffBasedAccount, this, true);
if (account instanceof PathBasedAccount pathBasedAccount) {
ACCOUNT mutableAccount = copyAccount((ACCOUNT) pathBasedAccount, this, true);
accountsToUpdate.put(
address, new DiffBasedValue<>((ACCOUNT) diffBasedAccount, mutableAccount));
address, new PathBasedValue<>((ACCOUNT) pathBasedAccount, mutableAccount));
return mutableAccount;
} else {
// add the empty read in accountsToUpdate
accountsToUpdate.put(address, new DiffBasedValue<>(null, null));
accountsToUpdate.put(address, new PathBasedValue<>(null, null));
return null;
}
} else {
return accountFunction.apply(diffBasedValue);
return accountFunction.apply(pathBasedValue);
}
} catch (MerkleTrieException e) {
// need to throw to trigger the heal
@@ -352,12 +352,12 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
this.isAccumulatorStateChanged = true;
for (final Address deletedAddress : getDeletedAccounts()) {
final DiffBasedValue<ACCOUNT> accountValue =
final PathBasedValue<ACCOUNT> accountValue =
accountsToUpdate.computeIfAbsent(
deletedAddress,
__ -> loadAccountFromParent(deletedAddress, new DiffBasedValue<>(null, null, true)));
__ -> loadAccountFromParent(deletedAddress, new PathBasedValue<>(null, null, true)));
storageToClear.add(deletedAddress);
final DiffBasedValue<Bytes> codeValue = codeToUpdate.get(deletedAddress);
final PathBasedValue<Bytes> codeValue = codeToUpdate.get(deletedAddress);
if (codeValue != null) {
codeValue.setUpdated(null).setCleared();
} else {
@@ -365,27 +365,27 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
.getCode(
deletedAddress,
Optional.ofNullable(accountValue)
.map(DiffBasedValue::getPrior)
.map(DiffBasedAccount::getCodeHash)
.map(PathBasedValue::getPrior)
.map(PathBasedAccount::getCodeHash)
.orElse(Hash.EMPTY))
.ifPresent(
deletedCode ->
codeToUpdate.put(
deletedAddress, new DiffBasedValue<>(deletedCode, null, true)));
deletedAddress, new PathBasedValue<>(deletedCode, null, true)));
}
// mark all updated storage as to be cleared
final Map<StorageSlotKey, DiffBasedValue<UInt256>> deletedStorageUpdates =
final Map<StorageSlotKey, PathBasedValue<UInt256>> deletedStorageUpdates =
storageToUpdate.computeIfAbsent(
deletedAddress,
k ->
new StorageConsumingMap<>(
deletedAddress, new ConcurrentHashMap<>(), storagePreloader));
final Iterator<Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>>> iter =
final Iterator<Map.Entry<StorageSlotKey, PathBasedValue<UInt256>>> iter =
deletedStorageUpdates.entrySet().iterator();
while (iter.hasNext()) {
final Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>> updateEntry = iter.next();
final DiffBasedValue<UInt256> updatedSlot = updateEntry.getValue();
final Map.Entry<StorageSlotKey, PathBasedValue<UInt256>> updateEntry = iter.next();
final PathBasedValue<UInt256> updatedSlot = updateEntry.getValue();
if (updatedSlot.getPrior() == null || updatedSlot.getPrior().isZero()) {
iter.remove();
} else {
@@ -405,7 +405,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
if (!deletedStorageUpdates.containsKey(storageSlotKey)) {
final UInt256 value = UInt256.fromBytes(RLP.decodeOne(entryValue));
deletedStorageUpdates.put(
storageSlotKey, new DiffBasedValue<>(value, null, true));
storageSlotKey, new PathBasedValue<>(value, null, true));
}
});
}
@@ -420,9 +420,9 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
tracked -> {
final Address updatedAddress = tracked.getAddress();
final ACCOUNT updatedAccount;
final DiffBasedValue<ACCOUNT> updatedAccountValue =
final PathBasedValue<ACCOUNT> updatedAccountValue =
accountsToUpdate.get(updatedAddress);
final Map<StorageSlotKey, DiffBasedValue<UInt256>> pendingStorageUpdates =
final Map<StorageSlotKey, PathBasedValue<UInt256>> pendingStorageUpdates =
storageToUpdate.computeIfAbsent(
updatedAddress,
k ->
@@ -433,9 +433,9 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
updatedAccount = createAccount(this, tracked);
tracked.setWrappedAccount(updatedAccount);
if (updatedAccountValue == null) {
accountsToUpdate.put(updatedAddress, new DiffBasedValue<>(null, updatedAccount));
accountsToUpdate.put(updatedAddress, new PathBasedValue<>(null, updatedAccount));
codeToUpdate.put(
updatedAddress, new DiffBasedValue<>(null, updatedAccount.getCode()));
updatedAddress, new PathBasedValue<>(null, updatedAccount.getCode()));
} else {
updatedAccountValue.setUpdated(updatedAccount);
}
@@ -453,17 +453,17 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
}
if (tracked.codeWasUpdated()) {
final DiffBasedValue<Bytes> pendingCode =
final PathBasedValue<Bytes> pendingCode =
codeToUpdate.computeIfAbsent(
updatedAddress,
addr ->
new DiffBasedValue<>(
new PathBasedValue<>(
wrappedWorldView()
.getCode(
addr,
Optional.ofNullable(updatedAccountValue)
.map(DiffBasedValue::getPrior)
.map(DiffBasedAccount::getCodeHash)
.map(PathBasedValue::getPrior)
.map(PathBasedAccount::getCodeHash)
.orElse(Hash.EMPTY))
.orElse(null),
null));
@@ -486,12 +486,12 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
new StorageSlotKey(
hashAndSaveSlotPreImage(keyUInt), Optional.of(keyUInt));
final UInt256 value = storageUpdate.getValue();
final DiffBasedValue<UInt256> pendingValue =
final PathBasedValue<UInt256> pendingValue =
pendingStorageUpdates.get(slotKey);
if (pendingValue == null) {
pendingStorageUpdates.put(
slotKey,
new DiffBasedValue<>(
new PathBasedValue<>(
updatedAccount.getOriginalStorageValue(keyUInt), value));
} else {
pendingValue.setUpdated(value);
@@ -512,7 +512,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
@Override
public Optional<Bytes> getCode(final Address address, final Hash codeHash) {
final DiffBasedValue<Bytes> localCode = codeToUpdate.get(address);
final PathBasedValue<Bytes> localCode = codeToUpdate.get(address);
if (localCode == null) {
final Optional<Bytes> code = wrappedWorldView().getCode(address, codeHash);
if (code.isEmpty() && !codeHash.equals(Hash.EMPTY)) {
@@ -535,17 +535,17 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
@Override
public Optional<UInt256> getStorageValueByStorageSlotKey(
final Address address, final StorageSlotKey storageSlotKey) {
final Map<StorageSlotKey, DiffBasedValue<UInt256>> localAccountStorage =
final Map<StorageSlotKey, PathBasedValue<UInt256>> localAccountStorage =
storageToUpdate.get(address);
if (localAccountStorage != null) {
final DiffBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey);
final PathBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey);
if (value != null) {
return Optional.ofNullable(value.getUpdated());
}
}
try {
final Optional<UInt256> valueUInt =
(wrappedWorldView() instanceof DiffBasedWorldState worldState)
(wrappedWorldView() instanceof PathBasedWorldState worldState)
? worldState.getStorageValueByStorageSlotKey(address, storageSlotKey)
: wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey);
storageToUpdate
@@ -554,7 +554,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
key ->
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader))
.put(
storageSlotKey, new DiffBasedValue<>(valueUInt.orElse(null), valueUInt.orElse(null)));
storageSlotKey, new PathBasedValue<>(valueUInt.orElse(null), valueUInt.orElse(null)));
return valueUInt;
} catch (MerkleTrieException e) {
// need to throw to trigger the heal
@@ -568,10 +568,10 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
// TODO maybe log the read into the trie layer?
StorageSlotKey storageSlotKey =
new StorageSlotKey(hashAndSaveSlotPreImage(storageKey), Optional.of(storageKey));
final Map<StorageSlotKey, DiffBasedValue<UInt256>> localAccountStorage =
final Map<StorageSlotKey, PathBasedValue<UInt256>> localAccountStorage =
storageToUpdate.get(address);
if (localAccountStorage != null) {
final DiffBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey);
final PathBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey);
if (value != null) {
if (value.isLastStepCleared()) {
return UInt256.ZERO;
@@ -595,11 +595,11 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
@Override
public Map<Bytes32, Bytes> getAllAccountStorage(final Address address, final Hash rootHash) {
final Map<Bytes32, Bytes> results = wrappedWorldView().getAllAccountStorage(address, rootHash);
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> diffBasedValueStorage =
final StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> pathBasedValueStorage =
storageToUpdate.get(address);
if (diffBasedValueStorage != null) {
if (pathBasedValueStorage != null) {
// hash the key to match the implied storage interface of hashed slotKey
diffBasedValueStorage.forEach(
pathBasedValueStorage.forEach(
(key, value) -> results.put(key.getSlotHash(), value.getUpdated()));
}
return results;
@@ -626,7 +626,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
}
@Override
public DiffBasedWorldStateKeyValueStorage getWorldStateStorage() {
public PathBasedWorldStateKeyValueStorage getWorldStateStorage() {
return wrappedWorldView().getWorldStateStorage();
}
@@ -678,7 +678,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
// non-change, a cached read.
return;
}
DiffBasedValue<ACCOUNT> accountValue = accountsToUpdate.get(address);
PathBasedValue<ACCOUNT> accountValue = accountsToUpdate.get(address);
if (accountValue == null) {
accountValue = loadAccountFromParent(address, accountValue);
}
@@ -686,7 +686,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
if (expectedValue == null && replacementValue != null) {
accountsToUpdate.put(
address,
new DiffBasedValue<>(null, createAccount(this, address, replacementValue, true)));
new PathBasedValue<>(null, createAccount(this, address, replacementValue, true)));
} else {
throw new IllegalStateException(
String.format(
@@ -719,13 +719,13 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
}
}
private DiffBasedValue<ACCOUNT> loadAccountFromParent(
final Address address, final DiffBasedValue<ACCOUNT> defaultValue) {
private PathBasedValue<ACCOUNT> loadAccountFromParent(
final Address address, final PathBasedValue<ACCOUNT> defaultValue) {
try {
final Account parentAccount = wrappedWorldView().get(address);
if (parentAccount instanceof DiffBasedAccount account) {
final DiffBasedValue<ACCOUNT> loadedAccountValue =
new DiffBasedValue<>(copyAccount((ACCOUNT) account), ((ACCOUNT) account));
if (parentAccount instanceof PathBasedAccount account) {
final PathBasedValue<ACCOUNT> loadedAccountValue =
new PathBasedValue<>(copyAccount((ACCOUNT) account), ((ACCOUNT) account));
accountsToUpdate.put(address, loadedAccountValue);
return loadedAccountValue;
} else {
@@ -744,7 +744,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
// non-change, a cached read.
return;
}
DiffBasedValue<Bytes> codeValue = codeToUpdate.get(address);
PathBasedValue<Bytes> codeValue = codeToUpdate.get(address);
if (codeValue == null) {
final Bytes storedCode =
wrappedWorldView()
@@ -752,14 +752,14 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
address, Optional.ofNullable(expectedCode).map(Hash::hash).orElse(Hash.EMPTY))
.orElse(Bytes.EMPTY);
if (!storedCode.isEmpty()) {
codeValue = new DiffBasedValue<>(storedCode, storedCode);
codeValue = new PathBasedValue<>(storedCode, storedCode);
codeToUpdate.put(address, codeValue);
}
}
if (codeValue == null) {
if ((expectedCode == null || expectedCode.isEmpty()) && replacementCode != null) {
codeToUpdate.put(address, new DiffBasedValue<>(null, replacementCode));
codeToUpdate.put(address, new PathBasedValue<>(null, replacementCode));
} else {
throw new IllegalStateException(
String.format(
@@ -787,10 +787,10 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
}
}
private Map<StorageSlotKey, DiffBasedValue<UInt256>> maybeCreateStorageMap(
final Map<StorageSlotKey, DiffBasedValue<UInt256>> storageMap, final Address address) {
private Map<StorageSlotKey, PathBasedValue<UInt256>> maybeCreateStorageMap(
final Map<StorageSlotKey, PathBasedValue<UInt256>> storageMap, final Address address) {
if (storageMap == null) {
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> newMap =
final StorageConsumingMap<StorageSlotKey, PathBasedValue<UInt256>> newMap =
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader);
storageToUpdate.put(address, newMap);
return newMap;
@@ -812,13 +812,13 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
// corner case on deletes, non-change
return;
}
final Map<StorageSlotKey, DiffBasedValue<UInt256>> storageMap = storageToUpdate.get(address);
DiffBasedValue<UInt256> slotValue = storageMap == null ? null : storageMap.get(storageSlotKey);
final Map<StorageSlotKey, PathBasedValue<UInt256>> storageMap = storageToUpdate.get(address);
PathBasedValue<UInt256> slotValue = storageMap == null ? null : storageMap.get(storageSlotKey);
if (slotValue == null) {
final Optional<UInt256> storageValue =
wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey);
if (storageValue.isPresent()) {
slotValue = new DiffBasedValue<>(storageValue.get(), storageValue.get());
slotValue = new PathBasedValue<>(storageValue.get(), storageValue.get());
storageToUpdate
.computeIfAbsent(
address,
@@ -830,7 +830,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
if (slotValue == null) {
if ((expectedValue == null || expectedValue.isZero()) && replacementValue != null) {
maybeCreateStorageMap(storageMap, address)
.put(storageSlotKey, new DiffBasedValue<>(null, replacementValue));
.put(storageSlotKey, new PathBasedValue<>(null, replacementValue));
} else {
throw new IllegalStateException(
String.format(
@@ -857,7 +857,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
existingSlotValue == null ? "null" : existingSlotValue.toShortHexString()));
}
if (replacementValue == null && slotValue.getPrior() == null) {
final Map<StorageSlotKey, DiffBasedValue<UInt256>> thisStorageUpdate =
final Map<StorageSlotKey, PathBasedValue<UInt256>> thisStorageUpdate =
maybeCreateStorageMap(storageMap, address);
thisStorageUpdate.remove(storageSlotKey);
if (thisStorageUpdate.isEmpty()) {
@@ -929,21 +929,21 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
return hash;
}
public abstract DiffBasedWorldStateUpdateAccumulator<ACCOUNT> copy();
public abstract PathBasedWorldStateUpdateAccumulator<ACCOUNT> copy();
protected abstract ACCOUNT copyAccount(final ACCOUNT account);
protected abstract ACCOUNT copyAccount(
final ACCOUNT toCopy, final DiffBasedWorldView context, final boolean mutable);
final ACCOUNT toCopy, final PathBasedWorldView context, final boolean mutable);
protected abstract ACCOUNT createAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final AccountValue stateTrieAccount,
final boolean mutable);
protected abstract ACCOUNT createAccount(
final DiffBasedWorldView context,
final PathBasedWorldView context,
final Address address,
final Hash addressHash,
final long nonce,
@@ -953,7 +953,7 @@ public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffB
final boolean mutable);
protected abstract ACCOUNT createAccount(
final DiffBasedWorldView context, final UpdateTrackingAccount<ACCOUNT> tracked);
final PathBasedWorldView context, final UpdateTrackingAccount<ACCOUNT> tracked);
protected abstract void assertCloseEnoughForDiffing(
final ACCOUNT source, final AccountValue account, final String context);

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/preload/AccountConsumingMap.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/accumulator/preload/AccountConsumingMap.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload;
import org.hyperledger.besu.datatypes.Address;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/preload/Consumer.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/accumulator/preload/Consumer.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload;
import org.hyperledger.besu.datatypes.Address;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/diffbased/common/worldview/accumulator/preload/StorageConsumingMap.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/trie/pathbased/common/worldview/accumulator/preload/StorageConsumingMap.java
View File

@@ -12,7 +12,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload;
package org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.accumulator.preload;
import org.hyperledger.besu.datatypes.Address;

16
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DataStorageConfiguration.java
View File

@@ -14,7 +14,7 @@
*/
package org.hyperledger.besu.ethereum.worldstate;
import org.hyperledger.besu.ethereum.worldstate.DiffBasedSubStorageConfiguration.DiffBasedUnstable;
import org.hyperledger.besu.ethereum.worldstate.PathBasedExtraStorageConfiguration.PathBasedUnstable;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
import org.immutables.value.Value;
@@ -28,7 +28,7 @@ public interface DataStorageConfiguration {
DataStorageConfiguration DEFAULT_CONFIG =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(DataStorageFormat.BONSAI)
.diffBasedSubStorageConfiguration(DiffBasedSubStorageConfiguration.DEFAULT)
.pathBasedExtraStorageConfiguration(PathBasedExtraStorageConfiguration.DEFAULT)
.build();
DataStorageConfiguration DEFAULT_BONSAI_CONFIG = DEFAULT_CONFIG;
@@ -36,23 +36,23 @@ public interface DataStorageConfiguration {
DataStorageConfiguration DEFAULT_BONSAI_PARTIAL_DB_CONFIG =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(DataStorageFormat.BONSAI)
.diffBasedSubStorageConfiguration(
ImmutableDiffBasedSubStorageConfiguration.builder()
.unstable(DiffBasedUnstable.PARTIAL_MODE)
.pathBasedExtraStorageConfiguration(
ImmutablePathBasedExtraStorageConfiguration.builder()
.unstable(PathBasedUnstable.PARTIAL_MODE)
.build())
.build();
DataStorageConfiguration DEFAULT_FOREST_CONFIG =
ImmutableDataStorageConfiguration.builder()
.dataStorageFormat(DataStorageFormat.FOREST)
.diffBasedSubStorageConfiguration(DiffBasedSubStorageConfiguration.DISABLED)
.pathBasedExtraStorageConfiguration(PathBasedExtraStorageConfiguration.DISABLED)
.build();
DataStorageFormat getDataStorageFormat();
@Value.Default
default DiffBasedSubStorageConfiguration getDiffBasedSubStorageConfiguration() {
return DiffBasedSubStorageConfiguration.DEFAULT;
default PathBasedExtraStorageConfiguration getPathBasedExtraStorageConfiguration() {
return PathBasedExtraStorageConfiguration.DEFAULT;
}
@Value.Default

30
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DiffBasedSubStorageConfiguration.java → ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/PathBasedExtraStorageConfiguration.java
View File

@@ -18,15 +18,15 @@ import org.immutables.value.Value;
@Value.Immutable
@Value.Enclosing
public interface DiffBasedSubStorageConfiguration {
public interface PathBasedExtraStorageConfiguration {
DiffBasedSubStorageConfiguration DEFAULT =
ImmutableDiffBasedSubStorageConfiguration.builder().build();
PathBasedExtraStorageConfiguration DEFAULT =
ImmutablePathBasedExtraStorageConfiguration.builder().build();
DiffBasedSubStorageConfiguration DISABLED =
ImmutableDiffBasedSubStorageConfiguration.builder()
PathBasedExtraStorageConfiguration DISABLED =
ImmutablePathBasedExtraStorageConfiguration.builder()
.limitTrieLogsEnabled(false)
.unstable(DiffBasedUnstable.DISABLED)
.unstable(PathBasedUnstable.DISABLED)
.build();
long DEFAULT_MAX_LAYERS_TO_LOAD = 512;
@@ -50,23 +50,23 @@ public interface DiffBasedSubStorageConfiguration {
}
@Value.Default
default DiffBasedUnstable getUnstable() {
return DiffBasedUnstable.DEFAULT;
default PathBasedUnstable getUnstable() {
return PathBasedUnstable.DEFAULT;
}
@Value.Immutable
interface DiffBasedUnstable {
interface PathBasedUnstable {
DiffBasedSubStorageConfiguration.DiffBasedUnstable DEFAULT =
ImmutableDiffBasedSubStorageConfiguration.DiffBasedUnstable.builder().build();
PathBasedExtraStorageConfiguration.PathBasedUnstable DEFAULT =
ImmutablePathBasedExtraStorageConfiguration.PathBasedUnstable.builder().build();
DiffBasedSubStorageConfiguration.DiffBasedUnstable PARTIAL_MODE =
ImmutableDiffBasedSubStorageConfiguration.DiffBasedUnstable.builder()
PathBasedExtraStorageConfiguration.PathBasedUnstable PARTIAL_MODE =
ImmutablePathBasedExtraStorageConfiguration.PathBasedUnstable.builder()
.fullFlatDbEnabled(false)
.build();
DiffBasedSubStorageConfiguration.DiffBasedUnstable DISABLED =
ImmutableDiffBasedSubStorageConfiguration.DiffBasedUnstable.builder()
PathBasedExtraStorageConfiguration.PathBasedUnstable DISABLED =
ImmutablePathBasedExtraStorageConfiguration.PathBasedUnstable.builder()
.fullFlatDbEnabled(false)
.codeStoredByCodeHashEnabled(false)
.isParallelTxProcessingEnabled(false)

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStateArchive.java
View File

@@ -19,7 +19,7 @@ import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.core.BlockHeader;
import org.hyperledger.besu.ethereum.core.MutableWorldState;
import org.hyperledger.besu.ethereum.proof.WorldStateProof;
import org.hyperledger.besu.ethereum.trie.diffbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.ethereum.trie.pathbased.common.provider.WorldStateQueryParams;
import org.hyperledger.besu.evm.worldstate.WorldState;
import java.io.Closeable;

2
ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/WorldStateStorageCoordinator.java
View File

@@ -15,8 +15,8 @@
package org.hyperledger.besu.ethereum.worldstate;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.plugin.services.storage.DataStorageFormat;
import java.util.Optional;

6
ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/InMemoryKeyValueStorageProvider.java
View File

@@ -27,12 +27,12 @@ import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStoragePrefixedKey
import org.hyperledger.besu.ethereum.storage.keyvalue.KeyValueStorageProvider;
import org.hyperledger.besu.ethereum.storage.keyvalue.VariablesKeyValueStorage;
import org.hyperledger.besu.ethereum.storage.keyvalue.WorldStatePreimageKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.forest.ForestWorldStateArchive;
import org.hyperledger.besu.ethereum.trie.forest.storage.ForestWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.forest.worldview.ForestMutableWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.cache.BonsaiCachedMerkleTrieLoader;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.WorldStateStorageCoordinator;
import org.hyperledger.besu.evm.internal.EvmConfiguration;

2
ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TrieGenerator.java
View File

@@ -21,7 +21,7 @@ import org.hyperledger.besu.datatypes.Wei;
import org.hyperledger.besu.ethereum.rlp.RLP;
import org.hyperledger.besu.ethereum.trie.MerkleTrie;
import org.hyperledger.besu.ethereum.trie.common.PmtStateTrieAccountValue;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.patricia.StoredMerklePatriciaTrie;
import org.hyperledger.besu.ethereum.worldstate.WorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.worldstate.WorldStateStorageCoordinator;

8
ethereum/core/src/test/java/org/hyperledger/besu/ethereum/BlockImportExceptionHandlingTest.java
View File

@@ -15,7 +15,7 @@
package org.hyperledger.besu.ethereum;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.WorldStateConfig.createStatefulConfigWithTrie;
import static org.hyperledger.besu.ethereum.trie.pathbased.common.worldview.WorldStateConfig.createStatefulConfigWithTrie;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
@@ -44,9 +44,9 @@ import org.hyperledger.besu.ethereum.mainnet.ProtocolSpec;
import org.hyperledger.besu.ethereum.mainnet.blockhash.FrontierBlockHashProcessor;
import org.hyperledger.besu.ethereum.mainnet.feemarket.FeeMarket;
import org.hyperledger.besu.ethereum.storage.StorageProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.BonsaiWorldStateProvider;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.storage.BonsaiWorldStateKeyValueStorage;
import org.hyperledger.besu.ethereum.trie.pathbased.bonsai.worldview.BonsaiWorldState;
import org.hyperledger.besu.ethereum.worldstate.DataStorageConfiguration;
import org.hyperledger.besu.ethereum.worldstate.WorldStateArchive;
import org.hyperledger.besu.ethereum.worldstate.WorldStateStorageCoordinator;

Some files were not shown because too many files have changed in this diff Show More