Rename accountOverride to stateOverride to match spec (#8111)

Signed-off-by: Gabriel-Trintinalia <gabriel.trintinalia@consensys.net>

besu/src/main/java/org/hyperledger/besu/services/BlockSimulatorServiceImpl.java

@@ -14,7 +14,7 @@
  */
 package org.hyperledger.besu.services;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Transaction;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
@@ -69,7 +69,7 @@ public class BlockSimulatorServiceImpl implements BlockSimulationService {
    * @param blockNumber the block number
    * @param transactions the transactions to include in the block
    * @param blockOverrides the blockSimulationOverride of the block
-   * @param accountOverrides state overrides of the block
+   * @param stateOverrides state overrides of the block
    * @return the block context
    */
   @Override
@@ -77,8 +77,8 @@ public class BlockSimulatorServiceImpl implements BlockSimulationService {
       final long blockNumber,
       final List<? extends Transaction> transactions,
       final BlockOverrides blockOverrides,
-      final AccountOverrideMap accountOverrides) {
-    return processSimulation(blockNumber, transactions, blockOverrides, accountOverrides, false);
+      final StateOverrideMap stateOverrides) {
+    return processSimulation(blockNumber, transactions, blockOverrides, stateOverrides, false);
   }
 
   /**
@@ -88,7 +88,7 @@ public class BlockSimulatorServiceImpl implements BlockSimulationService {
    * @param blockNumber the block number
    * @param transactions the transactions to include in the block
    * @param blockOverrides block overrides for the block
-   * @param accountOverrides state overrides of the block
+   * @param stateOverrides state overrides of the block
    * @return the PluginBlockSimulationResult
    */
   @Unstable
@@ -97,21 +97,21 @@ public class BlockSimulatorServiceImpl implements BlockSimulationService {
       final long blockNumber,
       final List<? extends Transaction> transactions,
       final BlockOverrides blockOverrides,
-      final AccountOverrideMap accountOverrides) {
-    return processSimulation(blockNumber, transactions, blockOverrides, accountOverrides, true);
+      final StateOverrideMap stateOverrides) {
+    return processSimulation(blockNumber, transactions, blockOverrides, stateOverrides, true);
   }
 
   private PluginBlockSimulationResult processSimulation(
       final long blockNumber,
       final List<? extends Transaction> transactions,
       final BlockOverrides blockOverrides,
-      final AccountOverrideMap accountOverrides,
+      final StateOverrideMap stateOverrides,
       final boolean persistWorldState) {
     BlockHeader header = getBlockHeader(blockNumber);
     List<CallParameter> callParameters =
         transactions.stream().map(CallParameter::fromTransaction).toList();
     BlockStateCall blockStateCall =
-        new BlockStateCall(callParameters, blockOverrides, accountOverrides, true);
+        new BlockStateCall(callParameters, blockOverrides, stateOverrides, true);
     try (final MutableWorldState ws = getWorldState(header, persistWorldState)) {
       List<BlockSimulationResult> results =
           blockSimulator.process(header, List.of(blockStateCall), ws);

besu/src/main/java/org/hyperledger/besu/services/TransactionSimulationServiceImpl.java

@@ -14,8 +14,8 @@
  */
 package org.hyperledger.besu.services;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Transaction;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.mainnet.TransactionValidationParams;
@@ -54,7 +54,7 @@ public class TransactionSimulationServiceImpl implements TransactionSimulationSe
   @Override
   public Optional<TransactionSimulationResult> simulate(
       final Transaction transaction,
-      final Optional<AccountOverrideMap> maybeAccountOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final Optional<Hash> maybeBlockHash,
       final OperationTracer operationTracer,
       final boolean isAllowExceedingBalance) {
@@ -89,7 +89,7 @@ public class TransactionSimulationServiceImpl implements TransactionSimulationSe
     return transactionSimulator
         .processOnPending(
             callParameter,
-            maybeAccountOverrides,
+            maybeStateOverrides,
             isAllowExceedingBalance
                 ? TransactionValidationParams.transactionSimulatorAllowExceedingBalance()
                 : TransactionValidationParams.transactionSimulator(),

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

@@ -28,16 +28,16 @@ import org.slf4j.LoggerFactory;
 
 /** Account Override parameter class */
 @JsonIgnoreProperties(ignoreUnknown = true)
-@JsonDeserialize(builder = AccountOverride.Builder.class)
-public class AccountOverride {
-  private static final Logger LOG = LoggerFactory.getLogger(AccountOverride.class);
+@JsonDeserialize(builder = StateOverride.Builder.class)
+public class StateOverride {
+  private static final Logger LOG = LoggerFactory.getLogger(StateOverride.class);
 
   private final Optional<Wei> balance;
   private final Optional<Long> nonce;
   private final Optional<String> code;
   private final Optional<Map<String, String>> stateDiff;
 
-  private AccountOverride(
+  private StateOverride(
       final Optional<Wei> balance,
       final Optional<Long> nonce,
       final Optional<String> code,
@@ -144,8 +144,8 @@ public class AccountOverride {
      *
      * @return account override
      */
-    public AccountOverride build() {
-      return new AccountOverride(balance, nonce, code, stateDiff);
+    public StateOverride build() {
+      return new StateOverride(balance, nonce, code, stateDiff);
     }
   }
 
@@ -172,11 +172,11 @@ public class AccountOverride {
     if (o == null || getClass() != o.getClass()) {
       return false;
     }
-    final AccountOverride accountOverride = (AccountOverride) o;
-    return balance.equals(accountOverride.balance)
-        && nonce.equals(accountOverride.nonce)
-        && code.equals(accountOverride.code)
-        && stateDiff.equals(accountOverride.stateDiff);
+    final StateOverride stateOverride = (StateOverride) o;
+    return balance.equals(stateOverride.balance)
+        && nonce.equals(stateOverride.nonce)
+        && code.equals(stateOverride.code)
+        && stateDiff.equals(stateOverride.stateDiff);
   }
 
   @Override
@@ -186,7 +186,7 @@ public class AccountOverride {
 
   @Override
   public String toString() {
-    return "AccountOverride{"
+    return "StateOverride{"
         + "balance="
         + balance
         + ", nonce="

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

@@ -20,8 +20,8 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 
 /** Map of account overrides, indexed by address */
 @JsonIgnoreProperties(ignoreUnknown = true)
-public class AccountOverrideMap extends HashMap<Address, AccountOverride> {
+public class StateOverrideMap extends HashMap<Address, StateOverride> {
 
   /** Default constructor */
-  public AccountOverrideMap() {}
+  public StateOverrideMap() {}
 }

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/AbstractEstimateGas.java

@@ -16,7 +16,7 @@ package org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods;
 
 import static org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.JsonCallParameterUtil.validateAndGetCallParams;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.api.jsonrpc.JsonRpcErrorConverter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequestContext;
@@ -76,7 +76,7 @@ public abstract class AbstractEstimateGas extends AbstractBlockParameterMethod {
   protected Object pendingResult(final JsonRpcRequestContext requestContext) {
     final JsonCallParameter jsonCallParameter = validateAndGetCallParams(requestContext);
     final var validationParams = getTransactionValidationParams(jsonCallParameter);
-    final var maybeStateOverrides = getAddressAccountOverrideMap(requestContext);
+    final var maybeStateOverrides = getAddressStateOverrideMap(requestContext);
     final var pendingBlockHeader = transactionSimulator.simulatePendingBlockHeader();
     final TransactionSimulationFunction simulationFunction =
         (cp, op) ->
@@ -103,7 +103,7 @@ public abstract class AbstractEstimateGas extends AbstractBlockParameterMethod {
       final JsonCallParameter jsonCallParameter,
       final BlockHeader blockHeader) {
     final var validationParams = getTransactionValidationParams(jsonCallParameter);
-    final var maybeStateOverrides = getAddressAccountOverrideMap(requestContext);
+    final var maybeStateOverrides = getAddressStateOverrideMap(requestContext);
     final TransactionSimulationFunction simulationFunction =
         (cp, op) ->
             transactionSimulator.process(
@@ -214,10 +214,10 @@ public abstract class AbstractEstimateGas extends AbstractBlockParameterMethod {
   }
 
   @VisibleForTesting
-  protected Optional<AccountOverrideMap> getAddressAccountOverrideMap(
+  protected Optional<StateOverrideMap> getAddressStateOverrideMap(
       final JsonRpcRequestContext request) {
     try {
-      return request.getOptionalParameter(2, AccountOverrideMap.class);
+      return request.getOptionalParameter(2, StateOverrideMap.class);
     } catch (JsonRpcParameter.JsonRpcParameterException e) {
       throw new InvalidJsonRpcRequestException(
           "Invalid account overrides parameter (index 2)", RpcErrorType.INVALID_CALL_PARAMS, e);

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthCall.java

@@ -17,8 +17,8 @@ package org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods;
 import static org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType.BLOCK_NOT_FOUND;
 import static org.hyperledger.besu.ethereum.api.jsonrpc.internal.response.RpcErrorType.INTERNAL_ERROR;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.api.jsonrpc.JsonRpcErrorConverter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.RpcMethod;
@@ -86,7 +86,7 @@ public class EthCall extends AbstractBlockParameterOrBlockHashMethod {
   protected Object resultByBlockHeader(
       final JsonRpcRequestContext request, final BlockHeader header) {
     JsonCallParameter callParams = JsonCallParameterUtil.validateAndGetCallParams(request);
-    Optional<AccountOverrideMap> maybeStateOverrides = getAddressAccountOverrideMap(request);
+    Optional<StateOverrideMap> maybeStateOverrides = getAddressStateOverrideMap(request);
     // TODO implement for block overrides
 
     return transactionSimulator
@@ -117,10 +117,10 @@ public class EthCall extends AbstractBlockParameterOrBlockHashMethod {
   }
 
   @VisibleForTesting
-  protected Optional<AccountOverrideMap> getAddressAccountOverrideMap(
+  protected Optional<StateOverrideMap> getAddressStateOverrideMap(
       final JsonRpcRequestContext request) {
     try {
-      return request.getOptionalParameter(2, AccountOverrideMap.class);
+      return request.getOptionalParameter(2, StateOverrideMap.class);
     } catch (JsonRpcParameterException e) {
       throw new InvalidJsonRpcRequestException(
           "Invalid account overrides parameter (index 2)", RpcErrorType.INVALID_CALL_PARAMS, e);

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthCallTest.java

@@ -27,10 +27,10 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.datatypes.parameters.UnsignedLongParameter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequest;
@@ -96,26 +96,26 @@ public class EthCallTest {
   }
 
   @Test
-  public void noAccountOverrides() {
+  public void noStateOverrides() {
     final JsonRpcRequestContext request = ethCallRequest(callParameter(), "latest");
-    Optional<AccountOverrideMap> overrideMap = method.getAddressAccountOverrideMap(request);
+    Optional<StateOverrideMap> overrideMap = method.getAddressStateOverrideMap(request);
     assertThat(overrideMap.isPresent()).isFalse();
   }
 
   @Test
-  public void someAccountOverrides() {
-    AccountOverrideMap expectedOverrides = new AccountOverrideMap();
-    AccountOverride override =
-        new AccountOverride.Builder().withNonce(new UnsignedLongParameter("0x9e")).build();
+  public void someStateOverrides() {
+    StateOverrideMap expectedOverrides = new StateOverrideMap();
+    StateOverride override =
+        new StateOverride.Builder().withNonce(new UnsignedLongParameter("0x9e")).build();
     final Address address = Address.fromHexString("0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3");
     expectedOverrides.put(address, override);
 
     final JsonRpcRequestContext request =
         ethCallRequestWithStateOverrides(callParameter(), "latest", expectedOverrides);
 
-    Optional<AccountOverrideMap> maybeOverrideMap = method.getAddressAccountOverrideMap(request);
+    Optional<StateOverrideMap> maybeOverrideMap = method.getAddressStateOverrideMap(request);
     assertThat(maybeOverrideMap.isPresent()).isTrue();
-    AccountOverrideMap overrideMap = maybeOverrideMap.get();
+    StateOverrideMap overrideMap = maybeOverrideMap.get();
     assertThat(overrideMap.keySet()).hasSize(1);
     assertThat(overrideMap.values()).hasSize(1);
 
@@ -498,7 +498,7 @@ public class EthCallTest {
   private JsonRpcRequestContext ethCallRequestWithStateOverrides(
       final CallParameter callParameter,
       final String blockNumberInHex,
-      final AccountOverrideMap overrides) {
+      final StateOverrideMap overrides) {
     return new JsonRpcRequestContext(
         new JsonRpcRequest(
             "2.0", "eth_call", new Object[] {callParameter, blockNumberInHex, overrides}));

ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/methods/EthEstimateGasTest.java

@@ -21,9 +21,9 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.datatypes.parameters.UnsignedLongParameter;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequest;
@@ -104,19 +104,19 @@ public class EthEstimateGasTest {
   }
 
   @Test
-  public void noAccountOverrides() {
+  public void noStateOverrides() {
     final Wei gasPrice = Wei.of(1000);
     final JsonRpcRequestContext request =
         ethEstimateGasRequest(defaultLegacyTransactionCallParameter(gasPrice), "latest");
-    Optional<AccountOverrideMap> overrideMap = method.getAddressAccountOverrideMap(request);
+    Optional<StateOverrideMap> overrideMap = method.getAddressStateOverrideMap(request);
     assertThat(overrideMap.isPresent()).isFalse();
   }
 
   @Test
-  public void someAccountOverrides() {
-    AccountOverrideMap expectedOverrides = new AccountOverrideMap();
-    AccountOverride override =
-        new AccountOverride.Builder().withNonce(new UnsignedLongParameter("0x9e")).build();
+  public void someStateOverrides() {
+    StateOverrideMap expectedOverrides = new StateOverrideMap();
+    StateOverride override =
+        new StateOverride.Builder().withNonce(new UnsignedLongParameter("0x9e")).build();
     final Address address = Address.fromHexString("0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3");
     expectedOverrides.put(address, override);
 
@@ -125,9 +125,9 @@ public class EthEstimateGasTest {
         ethEstimateGasRequestWithStateOverrides(
             defaultLegacyTransactionCallParameter(gasPrice), "latest", expectedOverrides);
 
-    Optional<AccountOverrideMap> maybeOverrideMap = method.getAddressAccountOverrideMap(request);
+    Optional<StateOverrideMap> maybeOverrideMap = method.getAddressStateOverrideMap(request);
     assertThat(maybeOverrideMap.isPresent()).isTrue();
-    AccountOverrideMap overrideMap = maybeOverrideMap.get();
+    StateOverrideMap overrideMap = maybeOverrideMap.get();
     assertThat(overrideMap.keySet()).hasSize(1);
     assertThat(overrideMap.values()).hasSize(1);
 
@@ -630,7 +630,7 @@ public class EthEstimateGasTest {
   private JsonRpcRequestContext ethEstimateGasRequestWithStateOverrides(
       final CallParameter callParameter,
       final String blockParam,
-      final AccountOverrideMap overrides) {
+      final StateOverrideMap overrides) {
     return new JsonRpcRequestContext(
         new JsonRpcRequest(
             "2.0", "eth_estimateGas", new Object[] {callParameter, blockParam, overrides}));

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

@@ -14,10 +14,10 @@
  */
 package org.hyperledger.besu.ethereum.transaction;
 
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.core.Block;
 import org.hyperledger.besu.ethereum.core.BlockBody;
@@ -141,7 +141,7 @@ public class BlockSimulator {
 
     // Apply block header overrides and state overrides
     BlockHeader blockHeader = applyBlockHeaderOverrides(header, newProtocolSpec, blockOverrides);
-    blockStateCall.getAccountOverrides().ifPresent(overrides -> applyStateOverrides(overrides, ws));
+    blockStateCall.getStateOverrideMap().ifPresent(overrides -> applyStateOverrides(overrides, ws));
 
     // Override the mining beneficiary calculator if a fee recipient is specified, otherwise use the
     // default
@@ -236,15 +236,15 @@ public class BlockSimulator {
   /**
    * Applies state overrides to the world state.
    *
-   * @param accountOverrideMap The AccountOverrideMap containing the state overrides.
+   * @param stateOverrideMap The StateOverrideMap containing the state overrides.
    * @param ws The MutableWorldState to apply the overrides to.
    */
   @VisibleForTesting
   protected void applyStateOverrides(
-      final AccountOverrideMap accountOverrideMap, final MutableWorldState ws) {
+      final StateOverrideMap stateOverrideMap, final MutableWorldState ws) {
     var updater = ws.updater();
-    for (Address accountToOverride : accountOverrideMap.keySet()) {
-      final AccountOverride override = accountOverrideMap.get(accountToOverride);
+    for (Address accountToOverride : stateOverrideMap.keySet()) {
+      final StateOverride override = stateOverrideMap.get(accountToOverride);
       MutableAccount account = updater.getOrCreate(accountToOverride);
       override.getNonce().ifPresent(account::setNonce);
       if (override.getBalance().isPresent()) {

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/transaction/BlockStateCall.java

@@ -14,7 +14,7 @@
  */
 package org.hyperledger.besu.ethereum.transaction;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.plugin.data.BlockOverrides;
 
 import java.util.ArrayList;
@@ -27,19 +27,19 @@ public class BlockStateCall {
 
   private final List<? extends CallParameter> calls;
 
-  private final AccountOverrideMap accountOverrides;
+  private final StateOverrideMap stateOverrideMap;
 
   private final boolean validation;
 
   public BlockStateCall(
       final List<? extends CallParameter> calls,
       final BlockOverrides blockOverrides,
-      final AccountOverrideMap accountOverrides,
+      final StateOverrideMap stateOverrideMap,
       final boolean validation) {
     this.calls = calls != null ? calls : new ArrayList<>();
     this.blockOverrides =
         blockOverrides != null ? blockOverrides : BlockOverrides.builder().build();
-    this.accountOverrides = accountOverrides;
+    this.stateOverrideMap = stateOverrideMap;
     this.validation = validation;
   }
 
@@ -51,8 +51,8 @@ public class BlockStateCall {
     return blockOverrides;
   }
 
-  public Optional<AccountOverrideMap> getAccountOverrides() {
-    return Optional.ofNullable(accountOverrides);
+  public Optional<StateOverrideMap> getStateOverrideMap() {
+    return Optional.ofNullable(stateOverrideMap);
   }
 
   public List<? extends CallParameter> getCalls() {

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

@@ -20,11 +20,11 @@ import static org.hyperledger.besu.ethereum.mainnet.feemarket.ExcessBlobGasCalcu
 import org.hyperledger.besu.crypto.SECPSignature;
 import org.hyperledger.besu.crypto.SignatureAlgorithm;
 import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.BlobGas;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
@@ -133,7 +133,7 @@ public class TransactionSimulator {
 
   public Optional<TransactionSimulatorResult> process(
       final CallParameter callParams,
-      final Optional<AccountOverrideMap> maybeStateOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final TransactionValidationParams transactionValidationParams,
       final OperationTracer operationTracer,
       final BlockHeader blockHeader) {
@@ -148,7 +148,7 @@ public class TransactionSimulator {
 
   public Optional<TransactionSimulatorResult> processOnPending(
       final CallParameter callParams,
-      final Optional<AccountOverrideMap> maybeStateOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final TransactionValidationParams transactionValidationParams,
       final OperationTracer operationTracer,
       final ProcessableBlockHeader pendingBlockHeader) {
@@ -271,7 +271,7 @@ public class TransactionSimulator {
    */
   public <U> Optional<U> process(
       final CallParameter callParams,
-      final Optional<AccountOverrideMap> maybeStateOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final TransactionValidationParams transactionValidationParams,
       final OperationTracer operationTracer,
       final PreCloseStateHandler<U> preWorldStateCloseGuard,
@@ -344,7 +344,7 @@ public class TransactionSimulator {
   @Nonnull
   public Optional<TransactionSimulatorResult> processWithWorldUpdater(
       final CallParameter callParams,
-      final Optional<AccountOverrideMap> maybeStateOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final TransactionValidationParams transactionValidationParams,
       final OperationTracer operationTracer,
       final BlockHeader header,
@@ -366,7 +366,7 @@ public class TransactionSimulator {
   @Nonnull
   public Optional<TransactionSimulatorResult> processWithWorldUpdater(
       final CallParameter callParams,
-      final Optional<AccountOverrideMap> maybeStateOverrides,
+      final Optional<StateOverrideMap> maybeStateOverrides,
       final TransactionValidationParams transactionValidationParams,
       final OperationTracer operationTracer,
       final ProcessableBlockHeader processableHeader,
@@ -391,7 +391,7 @@ public class TransactionSimulator {
     }
     if (maybeStateOverrides.isPresent()) {
       for (Address accountToOverride : maybeStateOverrides.get().keySet()) {
-        final AccountOverride overrides = maybeStateOverrides.get().get(accountToOverride);
+        final StateOverride overrides = maybeStateOverrides.get().get(accountToOverride);
         applyOverrides(updater.getOrCreate(accountToOverride), overrides);
       }
     }
@@ -449,7 +449,7 @@ public class TransactionSimulator {
   }
 
   @VisibleForTesting
-  protected void applyOverrides(final MutableAccount account, final AccountOverride override) {
+  protected void applyOverrides(final MutableAccount account, final StateOverride override) {
     LOG.debug("applying overrides to state for account {}", account.getAddress());
     override.getNonce().ifPresent(account::setNonce);
     if (override.getBalance().isPresent()) {

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/transaction/BlockSimulatorTest.java

@@ -25,10 +25,10 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.GasLimitCalculator;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
@@ -167,26 +167,25 @@ public class BlockSimulatorTest {
 
   @Test
   public void shouldApplyStateOverridesCorrectly() {
-    AccountOverrideMap accountOverrideMap = mock(AccountOverrideMap.class);
+    StateOverrideMap stateOverrideMap = mock(StateOverrideMap.class);
     Address address = mock(Address.class);
-    AccountOverride accountOverride = mock(AccountOverride.class);
+    StateOverride stateOverride = mock(StateOverride.class);
     MutableAccount mutableAccount = mock(MutableAccount.class);
 
-    when(accountOverrideMap.keySet()).thenReturn(Set.of(address));
-    when(accountOverrideMap.get(address)).thenReturn(accountOverride);
+    when(stateOverrideMap.keySet()).thenReturn(Set.of(address));
+    when(stateOverrideMap.get(address)).thenReturn(stateOverride);
 
     WorldUpdater worldUpdater = mock(WorldUpdater.class);
     when(mutableWorldState.updater()).thenReturn(worldUpdater);
 
     when(worldUpdater.getOrCreate(address)).thenReturn(mutableAccount);
 
-    when(accountOverride.getNonce()).thenReturn(Optional.of(123L));
-    when(accountOverride.getBalance()).thenReturn(Optional.of(Wei.of(456L)));
-    when(accountOverride.getCode()).thenReturn(Optional.of(""));
-    when(accountOverride.getStateDiff())
-        .thenReturn(Optional.of(new HashMap<>(Map.of("0x0", "0x1"))));
+    when(stateOverride.getNonce()).thenReturn(Optional.of(123L));
+    when(stateOverride.getBalance()).thenReturn(Optional.of(Wei.of(456L)));
+    when(stateOverride.getCode()).thenReturn(Optional.of(""));
+    when(stateOverride.getStateDiff()).thenReturn(Optional.of(new HashMap<>(Map.of("0x0", "0x1"))));
 
-    blockSimulator.applyStateOverrides(accountOverrideMap, mutableWorldState);
+    blockSimulator.applyStateOverrides(stateOverrideMap, mutableWorldState);
 
     verify(mutableAccount).setNonce(anyLong());
     verify(mutableAccount).setBalance(any(Wei.class));

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/transaction/TransactionSimulatorTest.java

@@ -28,10 +28,10 @@ import static org.mockito.Mockito.when;
 import org.hyperledger.besu.crypto.SECPSignature;
 import org.hyperledger.besu.crypto.SignatureAlgorithm;
 import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
-import org.hyperledger.besu.datatypes.AccountOverride;
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.BlobsWithCommitments;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverride;
 import org.hyperledger.besu.datatypes.TransactionType;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.GasLimitCalculator;
@@ -116,8 +116,8 @@ public class TransactionSimulatorTest {
   public void testOverrides_whenNoOverrides_noUpdates() {
     MutableAccount mutableAccount = mock(MutableAccount.class);
     when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM); // called from logging
-    AccountOverride.Builder builder = new AccountOverride.Builder();
-    AccountOverride override = builder.build();
+    StateOverride.Builder builder = new StateOverride.Builder();
+    StateOverride override = builder.build();
     transactionSimulator.applyOverrides(mutableAccount, override);
     verify(mutableAccount).getAddress();
     verifyNoMoreInteractions(mutableAccount);
@@ -127,8 +127,8 @@ public class TransactionSimulatorTest {
   public void testOverrides_whenBalanceOverrides_balanceIsUpdated() {
     MutableAccount mutableAccount = mock(MutableAccount.class);
     when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM);
-    AccountOverride.Builder builder = new AccountOverride.Builder().withBalance(Wei.of(99));
-    AccountOverride override = builder.build();
+    StateOverride.Builder builder = new StateOverride.Builder().withBalance(Wei.of(99));
+    StateOverride override = builder.build();
     transactionSimulator.applyOverrides(mutableAccount, override);
     verify(mutableAccount).setBalance(eq(Wei.of(99)));
   }
@@ -139,9 +139,9 @@ public class TransactionSimulatorTest {
     when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM);
     final String storageKey = "0x01a2";
     final String storageValue = "0x00ff";
-    AccountOverride.Builder builder =
-        new AccountOverride.Builder().withStateDiff(Map.of(storageKey, storageValue));
-    AccountOverride override = builder.build();
+    StateOverride.Builder builder =
+        new StateOverride.Builder().withStateDiff(Map.of(storageKey, storageValue));
+    StateOverride override = builder.build();
     transactionSimulator.applyOverrides(mutableAccount, override);
     verify(mutableAccount)
         .setStorageValue(

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/util/StateOverrideParameterTest.java

@@ -18,9 +18,9 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.hyperledger.besu.datatypes.AccountOverride;
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.datatypes.StateOverride;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Wei;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequest;
 import org.hyperledger.besu.ethereum.api.jsonrpc.internal.JsonRpcRequestContext;
@@ -30,7 +30,7 @@ import java.util.Optional;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.jupiter.api.Test;
 
-public class AccountOverrideParameterTest {
+public class StateOverrideParameterTest {
 
   private static final String ADDRESS_HEX1 = "0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3";
   private static final String ADDRESS_HEX2 = "0xd5E23607D5d73ff2293152f464C3caB005f87696";
@@ -56,15 +56,14 @@ public class AccountOverrideParameterTest {
             + "}}],\"id\":1}";
 
     final JsonRpcRequestContext request = new JsonRpcRequestContext(readJsonAsJsonRpcRequest(json));
-    final AccountOverrideMap accountOverrideParam =
-        request.getRequiredParameter(2, AccountOverrideMap.class);
+    final StateOverrideMap stateOverrideParam =
+        request.getRequiredParameter(2, StateOverrideMap.class);
 
-    final AccountOverride accountOverride =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
+    final StateOverride stateOverride = stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
 
-    assertThat(accountOverride.getNonce().get()).isEqualTo(158);
-    assertThat(accountOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
-    assertFalse(accountOverride.getStateDiff().isPresent());
+    assertThat(stateOverride.getNonce().get()).isEqualTo(158);
+    assertThat(stateOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
+    assertFalse(stateOverride.getStateDiff().isPresent());
   }
 
   @Test
@@ -84,16 +83,15 @@ public class AccountOverrideParameterTest {
             + "}}],\"id\":1}";
 
     final JsonRpcRequestContext request = new JsonRpcRequestContext(readJsonAsJsonRpcRequest(json));
-    final AccountOverrideMap accountOverrideParam =
-        request.getRequiredParameter(2, AccountOverrideMap.class);
+    final StateOverrideMap stateOverrideParam =
+        request.getRequiredParameter(2, StateOverrideMap.class);
 
-    final AccountOverride accountOverride =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
+    final StateOverride stateOverride = stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
 
-    assertFalse(accountOverride.getNonce().isPresent());
-    assertThat(accountOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
-    assertThat(accountOverride.getCode()).isEqualTo(Optional.of(CODE_STRING));
-    assertFalse(accountOverride.getStateDiff().isPresent());
+    assertFalse(stateOverride.getNonce().isPresent());
+    assertThat(stateOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
+    assertThat(stateOverride.getCode()).isEqualTo(Optional.of(CODE_STRING));
+    assertFalse(stateOverride.getStateDiff().isPresent());
   }
 
   @Test
@@ -113,15 +111,14 @@ public class AccountOverrideParameterTest {
             + "}}],\"id\":1}";
 
     final JsonRpcRequestContext request = new JsonRpcRequestContext(readJsonAsJsonRpcRequest(json));
-    final AccountOverrideMap accountOverrideParam =
-        request.getRequiredParameter(2, AccountOverrideMap.class);
+    final StateOverrideMap stateOverrideParam =
+        request.getRequiredParameter(2, StateOverrideMap.class);
 
-    final AccountOverride accountOverride =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
+    final StateOverride stateOverride = stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
 
-    assertThat(accountOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
-    assertThat(accountOverride.getNonce().get()).isEqualTo(158); // 0x9e
-    assertFalse(accountOverride.getStateDiff().isPresent());
+    assertThat(stateOverride.getBalance()).isEqualTo(Optional.of(Wei.of(1)));
+    assertThat(stateOverride.getNonce().get()).isEqualTo(158); // 0x9e
+    assertFalse(stateOverride.getStateDiff().isPresent());
   }
 
   @Test
@@ -146,20 +143,19 @@ public class AccountOverrideParameterTest {
 
     final JsonRpcRequestContext request = new JsonRpcRequestContext(readJsonAsJsonRpcRequest(json));
 
-    final AccountOverrideMap accountOverrideParam =
-        request.getRequiredParameter(2, AccountOverrideMap.class);
-    assertThat(accountOverrideParam.size()).isEqualTo(1);
+    final StateOverrideMap stateOverrideParam =
+        request.getRequiredParameter(2, StateOverrideMap.class);
+    assertThat(stateOverrideParam.size()).isEqualTo(1);
 
-    final AccountOverride accountOverride =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
-    assertThat(accountOverride.getNonce().get()).isEqualTo(158);
+    final StateOverride stateOverride = stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
+    assertThat(stateOverride.getNonce().get()).isEqualTo(158);
 
-    assertTrue(accountOverride.getStateDiff().isPresent());
-    assertThat(accountOverride.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
+    assertTrue(stateOverride.getStateDiff().isPresent());
+    assertThat(stateOverride.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
   }
 
   @Test
-  public void jsonWithMultipleAccountOverridesDeserializesCorrectly() throws Exception {
+  public void jsonWithMultipleStateOverridesDeserializesCorrectly() throws Exception {
     final String json =
         "{\"jsonrpc\":\"2.0\",\"method\":\"eth_call\",\"params\":[{"
             + "\"from\":\"0x0\", \"to\": \"0x0\"}, "
@@ -193,23 +189,23 @@ public class AccountOverrideParameterTest {
 
     final JsonRpcRequestContext request = new JsonRpcRequestContext(readJsonAsJsonRpcRequest(json));
 
-    final AccountOverrideMap accountOverrideParam =
-        request.getRequiredParameter(2, AccountOverrideMap.class);
-    assertThat(accountOverrideParam.size()).isEqualTo(2);
+    final StateOverrideMap stateOverrideParam =
+        request.getRequiredParameter(2, StateOverrideMap.class);
+    assertThat(stateOverrideParam.size()).isEqualTo(2);
 
-    final AccountOverride accountOverride1 =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
-    assertThat(accountOverride1.getNonce().get()).isEqualTo(158);
-    assertThat(accountOverride1.getBalance()).isEqualTo(Optional.of(Wei.fromHexString("0x01")));
-    assertTrue(accountOverride1.getStateDiff().isPresent());
-    assertThat(accountOverride1.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
+    final StateOverride stateOverride1 =
+        stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX1));
+    assertThat(stateOverride1.getNonce().get()).isEqualTo(158);
+    assertThat(stateOverride1.getBalance()).isEqualTo(Optional.of(Wei.fromHexString("0x01")));
+    assertTrue(stateOverride1.getStateDiff().isPresent());
+    assertThat(stateOverride1.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
 
-    final AccountOverride accountOverride2 =
-        accountOverrideParam.get(Address.fromHexString(ADDRESS_HEX2));
-    assertThat(accountOverride2.getNonce().get()).isEqualTo(157);
-    assertThat(accountOverride2.getBalance()).isEqualTo(Optional.of(Wei.fromHexString("0xFF")));
-    assertTrue(accountOverride2.getStateDiff().isPresent());
-    assertThat(accountOverride2.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
+    final StateOverride stateOverride2 =
+        stateOverrideParam.get(Address.fromHexString(ADDRESS_HEX2));
+    assertThat(stateOverride2.getNonce().get()).isEqualTo(157);
+    assertThat(stateOverride2.getBalance()).isEqualTo(Optional.of(Wei.fromHexString("0xFF")));
+    assertTrue(stateOverride2.getStateDiff().isPresent());
+    assertThat(stateOverride2.getStateDiff().get().get(STORAGE_KEY)).isEqualTo(STORAGE_VALUE);
   }
 
   private JsonRpcRequest readJsonAsJsonRpcRequest(final String json) throws java.io.IOException {

plugin-api/build.gradle

@@ -71,7 +71,7 @@ Calculated : ${currentHash}
 tasks.register('checkAPIChanges', FileStateChecker) {
   description = "Checks that the API for the Plugin-API project does not change without deliberate thought"
   files = sourceSets.main.allJava.files
-  knownHash = 'b/u9Ety5B+Ni8UwGhvU8dq4jcZtulNczsVQZgG0Q5fw='
+  knownHash = 'V3YwoXiJjbbrtpr7DmbebhJwAcj40J/3gb6VZcoFlF8='
 }
 check.dependsOn('checkAPIChanges')
 

plugin-api/src/main/java/org/hyperledger/besu/plugin/services/BlockSimulationService.java

@@ -14,7 +14,7 @@
  */
 package org.hyperledger.besu.plugin.services;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Transaction;
 import org.hyperledger.besu.plugin.Unstable;
 import org.hyperledger.besu.plugin.data.BlockOverrides;
@@ -31,14 +31,14 @@ public interface BlockSimulationService extends BesuService {
    * @param blockNumber the block number
    * @param transactions the transactions to include in the block
    * @param blockOverrides the blockSimulationOverride of the block
-   * @param accountOverrides state overrides of the block
+   * @param stateOverrides state overrides of the block
    * @return the block context
    */
   PluginBlockSimulationResult simulate(
       long blockNumber,
       List<? extends Transaction> transactions,
       BlockOverrides blockOverrides,
-      AccountOverrideMap accountOverrides);
+      StateOverrideMap stateOverrides);
 
   /**
    * This method is experimental and should be used with caution. Simulate the processing of a block
@@ -47,7 +47,7 @@ public interface BlockSimulationService extends BesuService {
    * @param blockNumber the block number
    * @param transactions the transactions to include in the block
    * @param blockOverrides block overrides for the block
-   * @param accountOverrides state overrides of the block
+   * @param stateOverrides state overrides of the block
    * @return the PluginBlockSimulationResult
    */
   @Unstable
@@ -55,5 +55,5 @@ public interface BlockSimulationService extends BesuService {
       long blockNumber,
       List<? extends Transaction> transactions,
       BlockOverrides blockOverrides,
-      AccountOverrideMap accountOverrides);
+      StateOverrideMap stateOverrides);
 }

plugin-api/src/main/java/org/hyperledger/besu/plugin/services/TransactionSimulationService.java

@@ -14,8 +14,8 @@
  */
 package org.hyperledger.besu.plugin.services;
 
-import org.hyperledger.besu.datatypes.AccountOverrideMap;
 import org.hyperledger.besu.datatypes.Hash;
+import org.hyperledger.besu.datatypes.StateOverrideMap;
 import org.hyperledger.besu.datatypes.Transaction;
 import org.hyperledger.besu.evm.tracing.OperationTracer;
 import org.hyperledger.besu.plugin.Unstable;
@@ -32,7 +32,7 @@ public interface TransactionSimulationService extends BesuService {
    * pending block, with optional state overrides that can be applied before the simulation.
    *
    * @param transaction tx
-   * @param accountOverrides state overrides to apply to this simulation
+   * @param stateOverrides state overrides to apply to this simulation
    * @param maybeBlockHash optional hash of the block, empty to simulate on pending block
    * @param operationTracer the tracer
    * @param isAllowExceedingBalance should ignore the sender balance during the simulation?
@@ -40,7 +40,7 @@ public interface TransactionSimulationService extends BesuService {
    */
   Optional<TransactionSimulationResult> simulate(
       Transaction transaction,
-      Optional<AccountOverrideMap> accountOverrides,
+      Optional<StateOverrideMap> stateOverrides,
       Optional<Hash> maybeBlockHash,
       OperationTracer operationTracer,
       boolean isAllowExceedingBalance);
@@ -93,7 +93,7 @@ public interface TransactionSimulationService extends BesuService {
    * overrides that can be applied before the simulation.
    *
    * @param transaction tx
-   * @param accountOverrides state overrides to apply to this simulation
+   * @param stateOverrides state overrides to apply to this simulation
    * @param blockHash the hash of the block
    * @param operationTracer the tracer
    * @param isAllowExceedingBalance should ignore the sender balance during the simulation?
@@ -103,13 +103,13 @@ public interface TransactionSimulationService extends BesuService {
   @Deprecated(since = "24.12", forRemoval = true)
   default Optional<TransactionSimulationResult> simulate(
       final Transaction transaction,
-      final Optional<AccountOverrideMap> accountOverrides,
+      final Optional<StateOverrideMap> stateOverrides,
       final Hash blockHash,
       final OperationTracer operationTracer,
       final boolean isAllowExceedingBalance) {
     return simulate(
         transaction,
-        accountOverrides,
+        stateOverrides,
         Optional.of(blockHash),
         operationTracer,
         isAllowExceedingBalance);