Simulation: Add state to StateOverride (eth_call, eth_simulateV1).

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

@@ -14,6 +14,8 @@
  */
 package org.hyperledger.besu.datatypes;
 
+import static com.google.common.base.Preconditions.checkState;
+
 import org.hyperledger.besu.datatypes.parameters.UnsignedLongParameter;
 
 import java.util.Map;
@@ -35,18 +37,21 @@ public class StateOverride {
   private final Optional<Wei> balance;
   private final Optional<Long> nonce;
   private final Optional<String> code;
+  private final Optional<Map<String, String>> state;
   private final Optional<Map<String, String>> stateDiff;
   private final Optional<Address> movePrecompileToAddress;
 
   private StateOverride(
       final Optional<Wei> balance,
       final Optional<Long> nonce,
       final Optional<String> code,
+      final Optional<Map<String, String>> state,
       final Optional<Map<String, String>> stateDiff,
       final Optional<Address> movePrecompileToAddress) {
     this.balance = balance;
     this.nonce = nonce;
     this.code = code;
+    this.state = state;
     this.stateDiff = stateDiff;
     this.movePrecompileToAddress = movePrecompileToAddress;
   }
@@ -83,6 +88,15 @@ public Optional<String> getCode() {
    *
    * @return the state override map if present
    */
+  public Optional<Map<String, String>> getState() {
+    return state;
+  }
+
+  /**
+   * Gets the state diff override map
+   *
+   * @return the state diff override map if present
+   */
   public Optional<Map<String, String>> getStateDiff() {
     return stateDiff;
   }
@@ -102,6 +116,7 @@ public static class Builder {
     private Optional<Wei> balance = Optional.empty();
     private Optional<Long> nonce = Optional.empty();
     private Optional<String> code = Optional.empty();
+    private Optional<Map<String, String>> state = Optional.empty();
     private Optional<Map<String, String>> stateDiff = Optional.empty();
     private Optional<Address> movePrecompileToAddress = Optional.empty();
 
@@ -141,6 +156,17 @@ public Builder withCode(final String code) {
       return this;
     }
 
+    /**
+     * Sets the state override
+     *
+     * @param state the map of state overrides
+     * @return the builder
+     */
+    public Builder withState(final Map<String, String> state) {
+      this.state = Optional.ofNullable(state);
+      return this;
+    }
+
     /**
      * Sets the state diff override
      *
@@ -169,7 +195,8 @@ public Builder withMovePrecompileToAddress(final Address newPrecompileAddress) {
      * @return account override
      */
     public StateOverride build() {
-      return new StateOverride(balance, nonce, code, stateDiff, movePrecompileToAddress);
+      checkState(state.isEmpty() || stateDiff.isEmpty(), "Cannot set both state and stateDiff");
+      return new StateOverride(balance, nonce, code, state, stateDiff, movePrecompileToAddress);
     }
   }
 
@@ -200,12 +227,13 @@ public boolean equals(final Object o) {
     return balance.equals(stateOverride.balance)
         && nonce.equals(stateOverride.nonce)
         && code.equals(stateOverride.code)
+        && state.equals(stateOverride.state)
         && stateDiff.equals(stateOverride.stateDiff);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(balance, nonce, code, stateDiff);
+    return Objects.hash(balance, nonce, code, state, stateDiff);
   }
 
   @Override
@@ -217,6 +245,8 @@ public String toString() {
         + nonce
         + ", code="
         + code
+        + ", state="
+        + state
         + ", stateDiff="
         + stateDiff
         + ", movePrecompileToAddress="

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

@@ -124,6 +124,27 @@ public void someStateOverrides() {
     assertThat(overrideMap).containsValue(override);
   }
 
+  @Test
+  public void stateOverridesWithState() {
+    StateOverrideMap expectedOverrides = new StateOverrideMap();
+    StateOverride override =
+        new StateOverride.Builder().withState(Map.of("0x1234", "0x5678")).build();
+    final Address address = Address.fromHexString("0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3");
+    expectedOverrides.put(address, override);
+
+    final JsonRpcRequestContext request =
+        ethCallRequestWithStateOverrides(callParameter(), "latest", expectedOverrides);
+
+    Optional<StateOverrideMap> maybeOverrideMap = method.getAddressStateOverrideMap(request);
+    assertThat(maybeOverrideMap.isPresent()).isTrue();
+    StateOverrideMap overrideMap = maybeOverrideMap.get();
+    assertThat(overrideMap.keySet()).hasSize(1);
+    assertThat(overrideMap.values()).hasSize(1);
+
+    assertThat(overrideMap).containsKey(address);
+    assertThat(overrideMap).containsValue(override);
+  }
+
   @Test
   public void fullStateOverrides() {
     StateOverrideMap suppliedOverrides = new StateOverrideMap();

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

@@ -52,7 +52,6 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import org.apache.tuweni.bytes.Bytes;
-import org.apache.tuweni.units.bigints.UInt256;
 
 /**
  * Simulates the execution of a block, processing transactions and applying state overrides. This
@@ -246,19 +245,7 @@ protected void applyStateOverrides(
     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()) {
-        account.setBalance(override.getBalance().get());
-      }
-      override.getCode().ifPresent(n -> account.setCode(Bytes.fromHexString(n)));
-      override
-          .getStateDiff()
-          .ifPresent(
-              d ->
-                  d.forEach(
-                      (key, value) ->
-                          account.setStorageValue(
-                              UInt256.fromHexString(key), UInt256.fromHexString(value))));
+      TransactionSimulator.applyOverrides(account, override);
     }
     updater.commit();
   }

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

@@ -459,13 +459,21 @@ public Optional<TransactionSimulatorResult> processWithWorldUpdater(
   }
 
   @VisibleForTesting
-  protected void applyOverrides(final MutableAccount account, final StateOverride override) {
+  protected static 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()) {
-      account.setBalance(override.getBalance().get());
-    }
-    override.getCode().ifPresent(n -> account.setCode(Bytes.fromHexString(n)));
+    override.getBalance().ifPresent(account::setBalance);
+    override.getCode().ifPresent(code -> account.setCode(Bytes.fromHexString(code)));
+    override
+        .getState()
+        .ifPresent(
+            d -> {
+              account.clearStorage();
+              d.forEach(
+                  (key, value) ->
+                      account.setStorageValue(
+                          UInt256.fromHexString(key), UInt256.fromHexString(value)));
+            });
     override
         .getStateDiff()
         .ifPresent(

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

@@ -30,6 +30,7 @@
 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.GasLimitCalculator;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderBuilder;
@@ -49,11 +50,9 @@
 
 import java.math.BigInteger;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 
 import org.apache.tuweni.bytes.Bytes;
 import org.apache.tuweni.units.bigints.UInt256;
@@ -167,24 +166,25 @@ public void shouldStopWhenTransactionSimulationIsEmpty() {
 
   @Test
   public void shouldApplyStateOverridesCorrectly() {
-    StateOverrideMap stateOverrideMap = mock(StateOverrideMap.class);
+    StateOverrideMap stateOverrideMap = new StateOverrideMap();
     Address address = mock(Address.class);
-    StateOverride stateOverride = mock(StateOverride.class);
-    MutableAccount mutableAccount = mock(MutableAccount.class);
+    StateOverride stateOverride =
+        new StateOverride.Builder()
+            .withBalance(Wei.of(456L))
+            .withNonce(new UnsignedLongParameter(123L))
+            .withCode("")
+            .withStateDiff(Map.of("0x0", "0x1"))
+            .build();
 
-    when(stateOverrideMap.keySet()).thenReturn(Set.of(address));
-    when(stateOverrideMap.get(address)).thenReturn(stateOverride);
+    stateOverrideMap.put(address, stateOverride);
 
     WorldUpdater worldUpdater = mock(WorldUpdater.class);
     when(mutableWorldState.updater()).thenReturn(worldUpdater);
 
+    MutableAccount mutableAccount = mock(MutableAccount.class);
+    when(mutableAccount.getAddress()).thenReturn(address);
     when(worldUpdater.getOrCreate(address)).thenReturn(mutableAccount);
 
-    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(stateOverrideMap, mutableWorldState);
 
     verify(mutableAccount).setNonce(anyLong());

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

@@ -120,7 +120,7 @@ public void testOverrides_whenNoOverrides_noUpdates() {
     when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM); // called from logging
     StateOverride.Builder builder = new StateOverride.Builder();
     StateOverride override = builder.build();
-    transactionSimulator.applyOverrides(mutableAccount, override);
+    TransactionSimulator.applyOverrides(mutableAccount, override);
     verify(mutableAccount).getAddress();
     verifyNoMoreInteractions(mutableAccount);
   }
@@ -131,7 +131,7 @@ public void testOverrides_whenBalanceOverrides_balanceIsUpdated() {
     when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM);
     StateOverride.Builder builder = new StateOverride.Builder().withBalance(Wei.of(99));
     StateOverride override = builder.build();
-    transactionSimulator.applyOverrides(mutableAccount, override);
+    TransactionSimulator.applyOverrides(mutableAccount, override);
     verify(mutableAccount).setBalance(eq(Wei.of(99)));
   }
 
@@ -144,7 +144,25 @@ public void testOverrides_whenStateDiffOverrides_stateIsUpdated() {
     StateOverride.Builder builder =
         new StateOverride.Builder().withStateDiff(Map.of(storageKey, storageValue));
     StateOverride override = builder.build();
-    transactionSimulator.applyOverrides(mutableAccount, override);
+    TransactionSimulator.applyOverrides(mutableAccount, override);
+    verify(mutableAccount)
+        .setStorageValue(
+            eq(UInt256.fromHexString(storageKey)), eq(UInt256.fromHexString(storageValue)));
+  }
+
+  @Test
+  public void testOverrides_whenStateOverrides_stateIsUpdated() {
+    MutableAccount mutableAccount = mock(MutableAccount.class);
+    when(mutableAccount.getAddress()).thenReturn(DEFAULT_FROM);
+    final String storageKey = "0x01a2";
+    final String storageValue = "0x00ff";
+    StateOverride.Builder builder =
+        new StateOverride.Builder().withState(Map.of(storageKey, storageValue));
+    StateOverride override = builder.build();
+    TransactionSimulator.applyOverrides(mutableAccount, override);
+
+    verify(mutableAccount).clearStorage();
+
     verify(mutableAccount)
         .setStorageValue(
             eq(UInt256.fromHexString(storageKey)), eq(UInt256.fromHexString(storageValue)));