[PAN-3122] Allow private contracts to access public state (#9)

* Allow private contracts to access public state

Signed-off-by: Joshua Richardson <joshua@richardson.tech>

acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyAcceptanceTestBase.java

@@ -21,6 +21,7 @@ import org.hyperledger.besu.tests.acceptance.dsl.privacy.condition.PrivateContra
 import org.hyperledger.besu.tests.acceptance.dsl.privacy.condition.PrivateTransactionVerifier;
 import org.hyperledger.besu.tests.acceptance.dsl.privacy.contract.PrivateContractTransactions;
 import org.hyperledger.besu.tests.acceptance.dsl.privacy.transaction.PrivacyTransactions;
+import org.hyperledger.besu.tests.acceptance.dsl.transaction.contract.ContractTransactions;
 import org.hyperledger.besu.tests.acceptance.dsl.transaction.net.NetTransactions;
 
 import org.junit.After;
@@ -37,7 +38,7 @@ public class PrivacyAcceptanceTestBase {
   protected final PrivateContractTransactions privateContractTransactions;
   protected final PrivacyCluster privacyCluster;
   protected final PrivacyAccountResolver privacyAccountResolver;
-
+  protected final ContractTransactions contractTransactions;
   protected final NetConditions net;
 
   public PrivacyAcceptanceTestBase() {
@@ -49,6 +50,7 @@ public class PrivacyAcceptanceTestBase {
     privateContractTransactions = new PrivateContractTransactions();
     privacyCluster = new PrivacyCluster(net);
     privacyAccountResolver = new PrivacyAccountResolver();
+    contractTransactions = new ContractTransactions();
   }
 
   @After

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/CrossContractReader.sol

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+pragma solidity >=0.4.0 <0.6.0;
+
+import "./EventEmitter.sol";
+
+// compile with:
+// solc CrossContractReader.sol --bin --abi --optimize --overwrite -o .
+// then create web3j wrappers with:
+// web3j solidity generate -b ./generated/CrossContractReader.bin -a ./generated/CrossContractReader.abi -o ../../../../../ -p org.hyperledger.besu.tests.web3j.generated
+contract CrossContractReader {
+    uint counter;
+
+    event NewEventEmitter(
+        address contractAddress
+    );
+
+    function read(address emitter_address) view public returns (uint) {
+        EventEmitter em = EventEmitter(emitter_address);
+        return em.value();
+    }
+
+    function deploy() public {
+        EventEmitter em = new EventEmitter();
+        emit NewEventEmitter(address(em));
+    }
+
+    function deployRemote(address crossAddress) public {
+        CrossContractReader cross = CrossContractReader(crossAddress);
+        cross.deploy();
+    }
+
+    function increment() public {
+        counter++;
+    }
+
+    function incrementRemote(address crossAddress) public {
+        CrossContractReader cross = CrossContractReader(crossAddress);
+        cross.increment();
+    }
+
+    function destroy() public {
+        selfdestruct(msg.sender);
+    }
+
+    function remoteDestroy(address crossAddress) public {
+        CrossContractReader cross = CrossContractReader(crossAddress);
+        cross.destroy();
+    }
+}

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.abi

@@ -0,0 +1 @@
+[{"constant":false,"inputs":[{"name":"crossAddress","type":"address"}],"name":"remoteDestroy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"crossAddress","type":"address"}],"name":"deployRemote","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"deploy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"destroy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"emitter_address","type":"address"}],"name":"read","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"increment","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"crossAddress","type":"address"}],"name":"incrementRemote","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"contractAddress","type":"address"}],"name":"NewEventEmitter","type":"event"}]

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.bin

@@ -0,0 +1 @@
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

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.java

@@ -0,0 +1,276 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.tests.web3j.generated;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import io.reactivex.Flowable;
+import org.web3j.abi.EventEncoder;
+import org.web3j.abi.TypeReference;
+import org.web3j.abi.datatypes.Address;
+import org.web3j.abi.datatypes.Event;
+import org.web3j.abi.datatypes.Function;
+import org.web3j.abi.datatypes.Type;
+import org.web3j.abi.datatypes.generated.Uint256;
+import org.web3j.crypto.Credentials;
+import org.web3j.protocol.Web3j;
+import org.web3j.protocol.core.DefaultBlockParameter;
+import org.web3j.protocol.core.RemoteCall;
+import org.web3j.protocol.core.RemoteFunctionCall;
+import org.web3j.protocol.core.methods.request.EthFilter;
+import org.web3j.protocol.core.methods.response.BaseEventResponse;
+import org.web3j.protocol.core.methods.response.Log;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
+import org.web3j.tx.Contract;
+import org.web3j.tx.TransactionManager;
+import org.web3j.tx.gas.ContractGasProvider;
+
+/**
+ * Auto generated code.
+ *
+ * <p><strong>Do not modify!</strong>
+ *
+ * <p>Please use the <a href="https://docs.web3j.io/command_line.html">web3j command line tools</a>,
+ * or the org.web3j.codegen.SolidityFunctionWrapperGenerator in the <a
+ * href="https://github.com/web3j/web3j/tree/master/codegen">codegen module</a> to update.
+ *
+ * <p>Generated with web3j version 4.5.0.
+ */
+@SuppressWarnings("rawtypes")
+public class CrossContractReader extends Contract {
+  private static final String BINARY =
+      "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";
+
+  public static final String FUNC_REMOTEDESTROY = "remoteDestroy";
+
+  public static final String FUNC_DEPLOYREMOTE = "deployRemote";
+
+  public static final String FUNC_DESTROY = "destroy";
+
+  public static final String FUNC_READ = "read";
+
+  public static final String FUNC_INCREMENT = "increment";
+
+  public static final String FUNC_INCREMENTREMOTE = "incrementRemote";
+
+  public static final Event NEWEVENTEMITTER_EVENT =
+      new Event(
+          "NewEventEmitter", Arrays.<TypeReference<?>>asList(new TypeReference<Address>() {}));;
+
+  @Deprecated
+  protected CrossContractReader(
+      String contractAddress,
+      Web3j web3j,
+      Credentials credentials,
+      BigInteger gasPrice,
+      BigInteger gasLimit) {
+    super(BINARY, contractAddress, web3j, credentials, gasPrice, gasLimit);
+  }
+
+  protected CrossContractReader(
+      String contractAddress,
+      Web3j web3j,
+      Credentials credentials,
+      ContractGasProvider contractGasProvider) {
+    super(BINARY, contractAddress, web3j, credentials, contractGasProvider);
+  }
+
+  @Deprecated
+  protected CrossContractReader(
+      String contractAddress,
+      Web3j web3j,
+      TransactionManager transactionManager,
+      BigInteger gasPrice,
+      BigInteger gasLimit) {
+    super(BINARY, contractAddress, web3j, transactionManager, gasPrice, gasLimit);
+  }
+
+  protected CrossContractReader(
+      String contractAddress,
+      Web3j web3j,
+      TransactionManager transactionManager,
+      ContractGasProvider contractGasProvider) {
+    super(BINARY, contractAddress, web3j, transactionManager, contractGasProvider);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> remoteDestroy(String crossAddress) {
+    final Function function =
+        new Function(
+            FUNC_REMOTEDESTROY,
+            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, crossAddress)),
+            Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> deployRemote(String crossAddress) {
+    final Function function =
+        new Function(
+            FUNC_DEPLOYREMOTE,
+            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, crossAddress)),
+            Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> deploy() {
+    final Function function =
+        new Function(FUNC_DEPLOY, Arrays.<Type>asList(), Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> destroy() {
+    final Function function =
+        new Function(
+            FUNC_DESTROY, Arrays.<Type>asList(), Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public RemoteFunctionCall<BigInteger> read(String emitter_address) {
+    final Function function =
+        new Function(
+            FUNC_READ,
+            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, emitter_address)),
+            Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
+    return executeRemoteCallSingleValueReturn(function, BigInteger.class);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> increment() {
+    final Function function =
+        new Function(
+            FUNC_INCREMENT, Arrays.<Type>asList(), Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public RemoteFunctionCall<TransactionReceipt> incrementRemote(String crossAddress) {
+    final Function function =
+        new Function(
+            FUNC_INCREMENTREMOTE,
+            Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(160, crossAddress)),
+            Collections.<TypeReference<?>>emptyList());
+    return executeRemoteCallTransaction(function);
+  }
+
+  public List<NewEventEmitterEventResponse> getNewEventEmitterEvents(
+      TransactionReceipt transactionReceipt) {
+    List<Contract.EventValuesWithLog> valueList =
+        extractEventParametersWithLog(NEWEVENTEMITTER_EVENT, transactionReceipt);
+    ArrayList<NewEventEmitterEventResponse> responses =
+        new ArrayList<NewEventEmitterEventResponse>(valueList.size());
+    for (Contract.EventValuesWithLog eventValues : valueList) {
+      NewEventEmitterEventResponse typedResponse = new NewEventEmitterEventResponse();
+      typedResponse.log = eventValues.getLog();
+      typedResponse.contractAddress = (String) eventValues.getNonIndexedValues().get(0).getValue();
+      responses.add(typedResponse);
+    }
+    return responses;
+  }
+
+  public Flowable<NewEventEmitterEventResponse> newEventEmitterEventFlowable(EthFilter filter) {
+    return web3j
+        .ethLogFlowable(filter)
+        .map(
+            new io.reactivex.functions.Function<Log, NewEventEmitterEventResponse>() {
+              @Override
+              public NewEventEmitterEventResponse apply(Log log) {
+                Contract.EventValuesWithLog eventValues =
+                    extractEventParametersWithLog(NEWEVENTEMITTER_EVENT, log);
+                NewEventEmitterEventResponse typedResponse = new NewEventEmitterEventResponse();
+                typedResponse.log = log;
+                typedResponse.contractAddress =
+                    (String) eventValues.getNonIndexedValues().get(0).getValue();
+                return typedResponse;
+              }
+            });
+  }
+
+  public Flowable<NewEventEmitterEventResponse> newEventEmitterEventFlowable(
+      DefaultBlockParameter startBlock, DefaultBlockParameter endBlock) {
+    EthFilter filter = new EthFilter(startBlock, endBlock, getContractAddress());
+    filter.addSingleTopic(EventEncoder.encode(NEWEVENTEMITTER_EVENT));
+    return newEventEmitterEventFlowable(filter);
+  }
+
+  @Deprecated
+  public static CrossContractReader load(
+      String contractAddress,
+      Web3j web3j,
+      Credentials credentials,
+      BigInteger gasPrice,
+      BigInteger gasLimit) {
+    return new CrossContractReader(contractAddress, web3j, credentials, gasPrice, gasLimit);
+  }
+
+  @Deprecated
+  public static CrossContractReader load(
+      String contractAddress,
+      Web3j web3j,
+      TransactionManager transactionManager,
+      BigInteger gasPrice,
+      BigInteger gasLimit) {
+    return new CrossContractReader(contractAddress, web3j, transactionManager, gasPrice, gasLimit);
+  }
+
+  public static CrossContractReader load(
+      String contractAddress,
+      Web3j web3j,
+      Credentials credentials,
+      ContractGasProvider contractGasProvider) {
+    return new CrossContractReader(contractAddress, web3j, credentials, contractGasProvider);
+  }
+
+  public static CrossContractReader load(
+      String contractAddress,
+      Web3j web3j,
+      TransactionManager transactionManager,
+      ContractGasProvider contractGasProvider) {
+    return new CrossContractReader(contractAddress, web3j, transactionManager, contractGasProvider);
+  }
+
+  public static RemoteCall<CrossContractReader> deploy(
+      Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) {
+    return deployRemoteCall(
+        CrossContractReader.class, web3j, credentials, contractGasProvider, BINARY, "");
+  }
+
+  @Deprecated
+  public static RemoteCall<CrossContractReader> deploy(
+      Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
+    return deployRemoteCall(
+        CrossContractReader.class, web3j, credentials, gasPrice, gasLimit, BINARY, "");
+  }
+
+  public static RemoteCall<CrossContractReader> deploy(
+      Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) {
+    return deployRemoteCall(
+        CrossContractReader.class, web3j, transactionManager, contractGasProvider, BINARY, "");
+  }
+
+  @Deprecated
+  public static RemoteCall<CrossContractReader> deploy(
+      Web3j web3j,
+      TransactionManager transactionManager,
+      BigInteger gasPrice,
+      BigInteger gasLimit) {
+    return deployRemoteCall(
+        CrossContractReader.class, web3j, transactionManager, gasPrice, gasLimit, BINARY, "");
+  }
+
+  public static class NewEventEmitterEventResponse extends BaseEventResponse {
+    public String contractAddress;
+  }
+}

acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/privacy/PrivateContractPublicStateAcceptanceTest.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.tests.web3j.privacy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.PrivacyAcceptanceTestBase;
+import org.hyperledger.besu.tests.acceptance.dsl.privacy.PrivacyNode;
+import org.hyperledger.besu.tests.web3j.generated.CrossContractReader;
+import org.hyperledger.besu.tests.web3j.generated.EventEmitter;
+
+import java.math.BigInteger;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.web3j.protocol.core.methods.response.TransactionReceipt;
+import org.web3j.protocol.pantheon.response.privacy.PrivateTransactionReceipt;
+import org.web3j.tx.exceptions.ContractCallException;
+
+public class PrivateContractPublicStateAcceptanceTest extends PrivacyAcceptanceTestBase {
+  private static final long POW_CHAIN_ID = 2018;
+
+  private PrivacyNode minerNode;
+
+  @Before
+  public void setUp() throws Exception {
+    minerNode =
+        privacyBesu.createPrivateTransactionEnabledMinerNode(
+            "miner-node", privacyAccountResolver.resolve(0));
+    privacyCluster.start(minerNode);
+  }
+
+  @Test
+  public void mustAllowAccessToPublicStateFromPrivateTx() throws Exception {
+    final EventEmitter publicEventEmitter =
+        minerNode.getBesu().execute((contractTransactions.createSmartContract(EventEmitter.class)));
+
+    final TransactionReceipt receipt = publicEventEmitter.store(BigInteger.valueOf(12)).send();
+    assertThat(receipt).isNotNull();
+
+    final CrossContractReader reader =
+        minerNode
+            .getBesu()
+            .execute(
+                privateContractTransactions.createSmartContract(
+                    CrossContractReader.class,
+                    minerNode.getTransactionSigningKey(),
+                    POW_CHAIN_ID,
+                    minerNode.getEnclaveKey()));
+
+    assertThat(reader.read(publicEventEmitter.getContractAddress()).send())
+        .isEqualTo(BigInteger.valueOf(12));
+  }
+
+  @Test(expected = ContractCallException.class)
+  public void mustNotAllowAccessToPrivateStateFromPublicTx() throws Exception {
+    final EventEmitter privateEventEmitter =
+        minerNode
+            .getBesu()
+            .execute(
+                (privateContractTransactions.createSmartContract(
+                    EventEmitter.class,
+                    minerNode.getTransactionSigningKey(),
+                    POW_CHAIN_ID,
+                    minerNode.getEnclaveKey())));
+
+    final TransactionReceipt receipt = privateEventEmitter.store(BigInteger.valueOf(12)).send();
+    assertThat(receipt).isNotNull();
+
+    final CrossContractReader publicReader =
+        minerNode
+            .getBesu()
+            .execute(contractTransactions.createSmartContract(CrossContractReader.class));
+
+    publicReader.read(privateEventEmitter.getContractAddress()).send();
+  }
+
+  @Test
+  public void privateContractMustNotBeAbleToCallPublicContractWhichChangesState() throws Exception {
+    final CrossContractReader privateReader =
+        minerNode
+            .getBesu()
+            .execute(
+                privateContractTransactions.createSmartContract(
+                    CrossContractReader.class,
+                    minerNode.getTransactionSigningKey(),
+                    POW_CHAIN_ID,
+                    minerNode.getEnclaveKey()));
+
+    final CrossContractReader publicReader =
+        minerNode
+            .getBesu()
+            .execute(contractTransactions.createSmartContract(CrossContractReader.class));
+
+    final PrivateTransactionReceipt transactionReceipt =
+        (PrivateTransactionReceipt)
+            privateReader.incrementRemote(publicReader.getContractAddress()).send();
+
+    assertThat(transactionReceipt.getOutput()).isEqualTo("0x");
+  }
+
+  @Test
+  public void privateContractMustNotBeAbleToCallPublicContractWhichInstantiatesContract()
+      throws Exception {
+    final CrossContractReader privateReader =
+        minerNode
+            .getBesu()
+            .execute(
+                privateContractTransactions.createSmartContract(
+                    CrossContractReader.class,
+                    minerNode.getTransactionSigningKey(),
+                    POW_CHAIN_ID,
+                    minerNode.getEnclaveKey()));
+
+    final CrossContractReader publicReader =
+        minerNode
+            .getBesu()
+            .execute(contractTransactions.createSmartContract(CrossContractReader.class));
+
+    final PrivateTransactionReceipt transactionReceipt =
+        (PrivateTransactionReceipt)
+            privateReader.deployRemote(publicReader.getContractAddress()).send();
+
+    assertThat(transactionReceipt.getLogs().size()).isEqualTo(0);
+  }
+
+  @Test
+  public void privateContractMustNotBeAbleToCallSelfDetructOfPublicContract() throws Exception {
+    final CrossContractReader privateReader =
+        minerNode
+            .getBesu()
+            .execute(
+                privateContractTransactions.createSmartContract(
+                    CrossContractReader.class,
+                    minerNode.getTransactionSigningKey(),
+                    POW_CHAIN_ID,
+                    minerNode.getEnclaveKey()));
+
+    final CrossContractReader publicReader =
+        minerNode
+            .getBesu()
+            .execute(contractTransactions.createSmartContract(CrossContractReader.class));
+
+    final PrivateTransactionReceipt transactionReceipt =
+        (PrivateTransactionReceipt)
+            privateReader.remoteDestroy(publicReader.getContractAddress()).send();
+
+    assertThat(transactionReceipt.getOutput()).isEqualTo("0x");
+  }
+}

ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java

@@ -21,8 +21,8 @@ import org.hyperledger.besu.ethereum.core.BlockBody;
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderBuilder;
 import org.hyperledger.besu.ethereum.core.BlockHeaderFunctions;
+import org.hyperledger.besu.ethereum.core.DefaultEvmAccount;
 import org.hyperledger.besu.ethereum.core.Hash;
-import org.hyperledger.besu.ethereum.core.MutableAccount;
 import org.hyperledger.besu.ethereum.core.MutableWorldState;
 import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader;
 import org.hyperledger.besu.ethereum.core.SealableBlockHeader;
@@ -294,9 +294,9 @@ public abstract class AbstractBlockCreator<C> implements AsyncBlockCreator {
     }
     final Wei coinbaseReward = blockReward.plus(blockReward.times(ommers.size()).dividedBy(32));
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount beneficiary = updater.getOrCreate(miningBeneficiary);
+    final DefaultEvmAccount beneficiary = updater.getOrCreate(miningBeneficiary);
 
-    beneficiary.incrementBalance(coinbaseReward);
+    beneficiary.getMutable().incrementBalance(coinbaseReward);
     for (final BlockHeader ommerHeader : ommers) {
       if (ommerHeader.getNumber() - header.getNumber() > MAX_GENERATION) {
         LOG.trace(
@@ -307,10 +307,10 @@ public abstract class AbstractBlockCreator<C> implements AsyncBlockCreator {
         return false;
       }
 
-      final MutableAccount ommerCoinbase = updater.getOrCreate(ommerHeader.getCoinbase());
+      final DefaultEvmAccount ommerCoinbase = updater.getOrCreate(ommerHeader.getCoinbase());
       final long distance = header.getNumber() - ommerHeader.getNumber();
       final Wei ommerReward = blockReward.minus(blockReward.times(distance).dividedBy(8));
-      ommerCoinbase.incrementBalance(ommerReward);
+      ommerCoinbase.getMutable().incrementBalance(ommerReward);
     }
 
     updater.commit();

ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/EntriesFromIntegrationTest.java

@@ -40,7 +40,7 @@ public class EntriesFromIntegrationTest {
     final MutableWorldState worldState =
         InMemoryStorageProvider.createInMemoryWorldStateArchive().getMutable();
     final WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.getOrCreate(Address.fromHexString("0x56"));
+    MutableAccount account = updater.getOrCreate(Address.fromHexString("0x56")).getMutable();
     final Map<Bytes32, AccountStorageEntry> expectedValues = new TreeMap<>();
     final int nodeCount = 100_000;
     final Random random = new Random(42989428249L);
@@ -53,7 +53,7 @@ public class EntriesFromIntegrationTest {
     updater.commit();
 
     // Add some changes on top that AbstractWorldUpdater.UpdateTrackingAccount will have to merge.
-    account = worldState.updater().getOrCreate(Address.fromHexString("0x56"));
+    account = worldState.updater().getOrCreate(Address.fromHexString("0x56")).getMutable();
     for (int i = 0; i <= nodeCount; i++) {
       addExpectedValue(
           account, expectedValues, UInt256.of(Math.abs(random.nextLong())), UInt256.of(i * 10 + 1));

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/GenesisState.java

@@ -112,7 +112,7 @@ public final class GenesisState {
     final WorldUpdater updater = target.updater();
     genesisAccounts.forEach(
         genesisAccount -> {
-          final MutableAccount account = updater.getOrCreate(genesisAccount.address);
+          final MutableAccount account = updater.getOrCreate(genesisAccount.address).getMutable();
           account.setNonce(genesisAccount.nonce);
           account.setBalance(genesisAccount.balance);
           account.setCode(genesisAccount.code);

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/AbstractWorldUpdater.java

@@ -59,11 +59,12 @@ public abstract class AbstractWorldUpdater<W extends WorldView, A extends Accoun
   }
 
   @Override
-  public MutableAccount createAccount(final Address address, final long nonce, final Wei balance) {
+  public DefaultEvmAccount createAccount(
+      final Address address, final long nonce, final Wei balance) {
     final UpdateTrackingAccount<A> account = new UpdateTrackingAccount<>(address);
     account.setNonce(nonce);
     account.setBalance(balance);
-    return track(account);
+    return new DefaultEvmAccount(track(account));
   }
 
   @Override
@@ -80,11 +81,11 @@ public abstract class AbstractWorldUpdater<W extends WorldView, A extends Accoun
   }
 
   @Override
-  public MutableAccount getMutable(final Address address) {
+  public DefaultEvmAccount getAccount(final Address address) {
     // We may have updated it already, so check that first.
     final MutableAccount existing = updatedAccounts.get(address);
     if (existing != null) {
-      return existing;
+      return new DefaultEvmAccount(existing);
     }
     if (deletedAccounts.contains(address)) {
       return null;
@@ -95,7 +96,7 @@ public abstract class AbstractWorldUpdater<W extends WorldView, A extends Accoun
     if (origin == null) {
       return null;
     } else {
-      return track(new UpdateTrackingAccount<>(origin));
+      return new DefaultEvmAccount(track(new UpdateTrackingAccount<>(origin)));
     }
   }
 

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/DefaultEvmAccount.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.core;
+
+import org.hyperledger.besu.util.bytes.Bytes32;
+import org.hyperledger.besu.util.bytes.BytesValue;
+import org.hyperledger.besu.util.uint.UInt256;
+
+import java.util.NavigableMap;
+
+public class DefaultEvmAccount implements EvmAccount {
+  private MutableAccount mutableAccount;
+
+  public boolean isImmutable() {
+    return isImmutable;
+  }
+
+  public void setImmutable(final boolean immutable) {
+    isImmutable = immutable;
+  }
+
+  private boolean isImmutable;
+
+  public DefaultEvmAccount(final MutableAccount mutableAccount) {
+
+    this.mutableAccount = mutableAccount;
+    this.isImmutable = false;
+  }
+
+  @Override
+  public MutableAccount getMutable() throws ModificationNotAllowedException {
+    if (isImmutable) {
+      throw new ModificationNotAllowedException();
+    }
+    return mutableAccount;
+  }
+
+  @Override
+  public Address getAddress() {
+    return mutableAccount.getAddress();
+  }
+
+  @Override
+  public Hash getAddressHash() {
+    return mutableAccount.getAddressHash();
+  }
+
+  @Override
+  public long getNonce() {
+    return mutableAccount.getNonce();
+  }
+
+  @Override
+  public Wei getBalance() {
+    return mutableAccount.getBalance();
+  }
+
+  @Override
+  public BytesValue getCode() {
+    return mutableAccount.getCode();
+  }
+
+  @Override
+  public Hash getCodeHash() {
+    return mutableAccount.getCodeHash();
+  }
+
+  @Override
+  public int getVersion() {
+    return mutableAccount.getVersion();
+  }
+
+  @Override
+  public UInt256 getStorageValue(final UInt256 key) {
+    return mutableAccount.getStorageValue(key);
+  }
+
+  @Override
+  public UInt256 getOriginalStorageValue(final UInt256 key) {
+    return mutableAccount.getOriginalStorageValue(key);
+  }
+
+  @Override
+  public NavigableMap<Bytes32, AccountStorageEntry> storageEntriesFrom(
+      final Bytes32 startKeyHash, final int limit) {
+    return mutableAccount.storageEntriesFrom(startKeyHash, limit);
+  }
+}

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/EvmAccount.java

@@ -0,0 +1,19 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.core;
+
+public interface EvmAccount extends Account {
+  public MutableAccount getMutable() throws ModificationNotAllowedException;
+}

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/ModificationNotAllowedException.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.core;
+
+public class ModificationNotAllowedException extends RuntimeException {
+  ModificationNotAllowedException() {
+    super("This account may not be modified");
+  }
+}

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/WorldUpdater.java

@@ -39,7 +39,7 @@ public interface WorldUpdater extends MutableWorldView {
    * @return the account {@code address}, which will have nonce {@code nonce}, balance {@code
    *     balance} and empty code and storage.
    */
-  MutableAccount createAccount(Address address, long nonce, Wei balance);
+  DefaultEvmAccount createAccount(Address address, long nonce, Wei balance);
 
   /**
    * Creates a new account, or reset it (that is, act as if it was deleted and created anew) if it
@@ -52,7 +52,7 @@ public interface WorldUpdater extends MutableWorldView {
    * @return the account {@code address}, which will have 0 for the nonce and balance and empty code
    *     and storage.
    */
-  default MutableAccount createAccount(final Address address) {
+  default DefaultEvmAccount createAccount(final Address address) {
     return createAccount(address, Account.DEFAULT_NONCE, Account.DEFAULT_BALANCE);
   }
 
@@ -61,11 +61,11 @@ public interface WorldUpdater extends MutableWorldView {
    *
    * @param address the address of the account.
    * @return the account {@code address}. If that account exists, it is returned as if by {@link
-   *     #getMutable(Address)}, otherwise, it is created and returned as if by {@link
+   *     #getAccount(Address)}, otherwise, it is created and returned as if by {@link
    *     #createAccount(Address)} (and thus all his fields will be zero/empty).
    */
-  default MutableAccount getOrCreate(final Address address) {
-    final MutableAccount account = getMutable(address);
+  default DefaultEvmAccount getOrCreate(final Address address) {
+    final DefaultEvmAccount account = getAccount(address);
     return account == null ? createAccount(address) : account;
   }
 
@@ -74,10 +74,9 @@ public interface WorldUpdater extends MutableWorldView {
    * this updater).
    *
    * @param address the address of the account.
-   * @return the account {@code address} as modifiable object, or {@code null} if the account does
-   *     not exist.
+   * @return the account {@code address}, or {@code null} if the account does not exist.
    */
-  MutableAccount getMutable(Address address);
+  DefaultEvmAccount getAccount(Address address);
 
   /**
    * Deletes the provided account.

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java

@@ -167,7 +167,7 @@ public class MainnetBlockProcessor implements BlockProcessor {
     }
     final Wei coinbaseReward = blockReward.plus(blockReward.times(ommers.size()).dividedBy(32));
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount coinbase = updater.getOrCreate(header.getCoinbase());
+    final MutableAccount coinbase = updater.getOrCreate(header.getCoinbase()).getMutable();
 
     coinbase.incrementBalance(coinbaseReward);
     for (final BlockHeader ommerHeader : ommers) {
@@ -180,7 +180,8 @@ public class MainnetBlockProcessor implements BlockProcessor {
         return false;
       }
 
-      final MutableAccount ommerCoinbase = updater.getOrCreate(ommerHeader.getCoinbase());
+      final MutableAccount ommerCoinbase =
+          updater.getOrCreate(ommerHeader.getCoinbase()).getMutable();
       final long distance = header.getNumber() - ommerHeader.getNumber();
       final Wei ommerReward = blockReward.minus(blockReward.times(distance).dividedBy(8));
       ommerCoinbase.incrementBalance(ommerReward);

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetContractCreationProcessor.java

@@ -17,6 +17,7 @@ package org.hyperledger.besu.ethereum.mainnet;
 import org.hyperledger.besu.ethereum.core.Account;
 import org.hyperledger.besu.ethereum.core.Address;
 import org.hyperledger.besu.ethereum.core.Gas;
+import org.hyperledger.besu.ethereum.core.ModificationNotAllowedException;
 import org.hyperledger.besu.ethereum.core.MutableAccount;
 import org.hyperledger.besu.ethereum.vm.EVM;
 import org.hyperledger.besu.ethereum.vm.GasCalculator;
@@ -105,11 +106,13 @@ public class MainnetContractCreationProcessor extends AbstractMessageProcessor {
     if (LOG.isTraceEnabled()) {
       LOG.trace("Executing contract-creation");
     }
-
-    final MutableAccount sender = frame.getWorldState().getMutable(frame.getSenderAddress());
+    try {
+      final MutableAccount sender =
+          frame.getWorldState().getAccount(frame.getSenderAddress()).getMutable();
       sender.decrementBalance(frame.getValue());
 
-    final MutableAccount contract = frame.getWorldState().getOrCreate(frame.getContractAddress());
+      final MutableAccount contract =
+          frame.getWorldState().getOrCreate(frame.getContractAddress()).getMutable();
       if (accountExists(contract)) {
         LOG.trace(
             "Contract creation error: account as already been created for address {}",
@@ -121,6 +124,10 @@ public class MainnetContractCreationProcessor extends AbstractMessageProcessor {
         contract.clearStorage();
         frame.setState(MessageFrame.State.CODE_EXECUTING);
       }
+    } catch (ModificationNotAllowedException ex) {
+      LOG.trace("Contract creation error: illegal modification not allowed from private state");
+      frame.setState(MessageFrame.State.EXCEPTIONAL_HALT);
+    }
   }
 
   @Override
@@ -148,7 +155,7 @@ public class MainnetContractCreationProcessor extends AbstractMessageProcessor {
 
         // Finalize contract creation, setting the contract code.
         final MutableAccount contract =
-            frame.getWorldState().getOrCreate(frame.getContractAddress());
+            frame.getWorldState().getOrCreate(frame.getContractAddress()).getMutable();
         contract.setCode(contractCode);
         contract.setVersion(accountVersion);
         LOG.trace(

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetMessageCallProcessor.java

@@ -16,6 +16,7 @@ package org.hyperledger.besu.ethereum.mainnet;
 
 import org.hyperledger.besu.ethereum.core.Address;
 import org.hyperledger.besu.ethereum.core.Gas;
+import org.hyperledger.besu.ethereum.core.ModificationNotAllowedException;
 import org.hyperledger.besu.ethereum.core.MutableAccount;
 import org.hyperledger.besu.ethereum.core.Wei;
 import org.hyperledger.besu.ethereum.vm.EVM;
@@ -49,7 +50,7 @@ public class MainnetMessageCallProcessor extends AbstractMessageProcessor {
   @Override
   public void start(final MessageFrame frame) {
     LOG.trace("Executing message-call");
-
+    try {
       transferValue(frame);
 
       // Check first if the message call is to a pre-compile contract
@@ -60,6 +61,10 @@ public class MainnetMessageCallProcessor extends AbstractMessageProcessor {
       } else {
         frame.setState(MessageFrame.State.CODE_EXECUTING);
       }
+    } catch (ModificationNotAllowedException ex) {
+      LOG.trace("Message call error: illegal modification not allowed from private state");
+      frame.setState(MessageFrame.State.EXCEPTIONAL_HALT);
+    }
   }
 
   @Override
@@ -79,11 +84,12 @@ public class MainnetMessageCallProcessor extends AbstractMessageProcessor {
    * of the world state of this executor.
    */
   private void transferValue(final MessageFrame frame) {
-    final MutableAccount senderAccount = frame.getWorldState().getMutable(frame.getSenderAddress());
+    final MutableAccount senderAccount =
+        frame.getWorldState().getAccount(frame.getSenderAddress()).getMutable();
     // The yellow paper explicitly states that if the recipient account doesn't exist at this
     // point, it is created.
     final MutableAccount recipientAccount =
-        frame.getWorldState().getOrCreate(frame.getRecipientAddress());
+        frame.getWorldState().getOrCreate(frame.getRecipientAddress()).getMutable();
 
     if (frame.getRecipientAddress().equals(frame.getSenderAddress())) {
       LOG.trace("Message call of {} to itself: no fund transferred", frame.getSenderAddress());

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java

@@ -370,9 +370,9 @@ public abstract class MainnetProtocolSpecs {
                 .collect(Collectors.toList());
         final WorldUpdater worldUpdater = worldState.updater();
         final MutableAccount daoRefundContract =
-            worldUpdater.getOrCreate(DAO_REFUND_CONTRACT_ADDRESS);
+            worldUpdater.getOrCreate(DAO_REFUND_CONTRACT_ADDRESS).getMutable();
         for (final Address address : addresses) {
-          final MutableAccount account = worldUpdater.getOrCreate(address);
+          final MutableAccount account = worldUpdater.getOrCreate(address).getMutable();
           final Wei balance = account.getBalance();
           account.decrementBalance(balance);
           daoRefundContract.incrementBalance(balance);

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java

@@ -17,6 +17,7 @@ package org.hyperledger.besu.ethereum.mainnet;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.Account;
 import org.hyperledger.besu.ethereum.core.Address;
+import org.hyperledger.besu.ethereum.core.DefaultEvmAccount;
 import org.hyperledger.besu.ethereum.core.Gas;
 import org.hyperledger.besu.ethereum.core.LogSeries;
 import org.hyperledger.besu.ethereum.core.MutableAccount;
@@ -189,7 +190,7 @@ public class MainnetTransactionProcessor implements TransactionProcessor {
     }
 
     final Address senderAddress = transaction.getSender();
-    final MutableAccount sender = worldState.getOrCreate(senderAddress);
+    final DefaultEvmAccount sender = worldState.getOrCreate(senderAddress);
     validationResult =
         transactionValidator.validateForSender(transaction, sender, transactionValidationParams);
     if (!validationResult.isValid()) {
@@ -197,12 +198,13 @@ public class MainnetTransactionProcessor implements TransactionProcessor {
       return Result.invalid(validationResult);
     }
 
-    final long previousNonce = sender.incrementNonce();
+    final MutableAccount senderMutableAccount = sender.getMutable();
+    final long previousNonce = senderMutableAccount.incrementNonce();
     LOG.trace(
         "Incremented sender {} nonce ({} -> {})", senderAddress, previousNonce, sender.getNonce());
 
     final Wei upfrontGasCost = transaction.getUpfrontGasCost();
-    final Wei previousBalance = sender.decrementBalance(upfrontGasCost);
+    final Wei previousBalance = senderMutableAccount.decrementBalance(upfrontGasCost);
     LOG.trace(
         "Deducted sender {} upfront gas cost {} ({} -> {})",
         senderAddress,
@@ -307,9 +309,9 @@ public class MainnetTransactionProcessor implements TransactionProcessor {
     final Gas refundGas = initialFrame.getGasRefund().plus(selfDestructRefund);
     final Gas refunded = refunded(transaction, initialFrame.getRemainingGas(), refundGas);
     final Wei refundedWei = refunded.priceFor(transaction.getGasPrice());
-    sender.incrementBalance(refundedWei);
+    senderMutableAccount.incrementBalance(refundedWei);
 
-    final MutableAccount coinbase = worldState.getOrCreate(miningBeneficiary);
+    final MutableAccount coinbase = worldState.getOrCreate(miningBeneficiary).getMutable();
     final Gas coinbaseFee = Gas.of(transaction.getGasLimit()).minus(refunded);
     final Wei coinbaseWei = coinbaseFee.priceFor(transaction.getGasPrice());
     coinbase.incrementBalance(coinbaseWei);

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionProcessor.java

@@ -17,6 +17,7 @@ package org.hyperledger.besu.ethereum.privacy;
 import org.hyperledger.besu.ethereum.chain.Blockchain;
 import org.hyperledger.besu.ethereum.core.Account;
 import org.hyperledger.besu.ethereum.core.Address;
+import org.hyperledger.besu.ethereum.core.DefaultEvmAccount;
 import org.hyperledger.besu.ethereum.core.Gas;
 import org.hyperledger.besu.ethereum.core.LogSeries;
 import org.hyperledger.besu.ethereum.core.MutableAccount;
@@ -33,6 +34,7 @@ import org.hyperledger.besu.ethereum.vm.Code;
 import org.hyperledger.besu.ethereum.vm.GasCalculator;
 import org.hyperledger.besu.ethereum.vm.MessageFrame;
 import org.hyperledger.besu.ethereum.vm.OperationTracer;
+import org.hyperledger.besu.ethereum.worldstate.DefaultMutablePrivateWorldStateUpdater;
 import org.hyperledger.besu.util.bytes.BytesValue;
 
 import java.util.ArrayDeque;
@@ -190,11 +192,11 @@ public class PrivateTransactionProcessor {
     LOG.trace("Starting private execution of {}", transaction);
 
     final Address senderAddress = transaction.getSender();
-    final MutableAccount maybePrivateSender = privateWorldState.getMutable(senderAddress);
+    final DefaultEvmAccount maybePrivateSender = privateWorldState.getAccount(senderAddress);
     final MutableAccount sender =
         maybePrivateSender != null
-            ? maybePrivateSender
-            : privateWorldState.createAccount(senderAddress, 0, Wei.ZERO);
+            ? maybePrivateSender.getMutable()
+            : privateWorldState.createAccount(senderAddress, 0, Wei.ZERO).getMutable();
 
     final ValidationResult<TransactionValidator.TransactionInvalidReason> validationResult =
         privateTransactionValidator.validate(transaction, sender.getNonce());
@@ -211,6 +213,10 @@ public class PrivateTransactionProcessor {
 
     final MessageFrame initialFrame;
     final Deque<MessageFrame> messageFrameStack = new ArrayDeque<>();
+
+    final WorldUpdater mutablePrivateWorldStateUpdater =
+        new DefaultMutablePrivateWorldStateUpdater(publicWorldState, privateWorldState);
+
     if (transaction.isContractCreation()) {
       final Address privateContractAddress =
           Address.privateContractAddress(senderAddress, previousNonce, privacyGroupId);
@@ -227,7 +233,7 @@ public class PrivateTransactionProcessor {
               .type(MessageFrame.Type.CONTRACT_CREATION)
               .messageFrameStack(messageFrameStack)
               .blockchain(blockchain)
-              .worldState(privateWorldState.updater())
+              .worldState(mutablePrivateWorldStateUpdater)
               .address(privateContractAddress)
               .originator(senderAddress)
               .contract(privateContractAddress)
@@ -256,7 +262,7 @@ public class PrivateTransactionProcessor {
               .type(MessageFrame.Type.MESSAGE_CALL)
               .messageFrameStack(messageFrameStack)
               .blockchain(blockchain)
-              .worldState(privateWorldState.updater())
+              .worldState(mutablePrivateWorldStateUpdater)
               .address(to)
               .originator(senderAddress)
               .contract(to)
@@ -285,7 +291,7 @@ public class PrivateTransactionProcessor {
     }
 
     if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {
-      privateWorldState.commit();
+      mutablePrivateWorldStateUpdater.commit();
     }
 
     if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) {

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracer.java

@@ -18,6 +18,7 @@ import static org.hyperledger.besu.util.uint.UInt256.U_32;
 
 import org.hyperledger.besu.ethereum.core.Address;
 import org.hyperledger.besu.ethereum.core.Gas;
+import org.hyperledger.besu.ethereum.core.ModificationNotAllowedException;
 import org.hyperledger.besu.ethereum.core.Wei;
 import org.hyperledger.besu.ethereum.debug.TraceFrame;
 import org.hyperledger.besu.ethereum.debug.TraceOptions;
@@ -82,10 +83,18 @@ public class DebugOperationTracer implements OperationTracer {
     if (!options.isStorageEnabled()) {
       return Optional.empty();
     }
+    try {
       final Map<UInt256, UInt256> storageContents =
           new TreeMap<>(
-            frame.getWorldState().getMutable(frame.getRecipientAddress()).getUpdatedStorage());
+              frame
+                  .getWorldState()
+                  .getAccount(frame.getRecipientAddress())
+                  .getMutable()
+                  .getUpdatedStorage());
       return Optional.of(storageContents);
+    } catch (ModificationNotAllowedException e) {
+      return Optional.of(new TreeMap<>());
+    }
   }
 
   private Optional<Bytes32[]> captureMemory(final MessageFrame frame) {

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/AbstractCreateOperation.java

@@ -57,7 +57,7 @@ public abstract class AbstractCreateOperation extends AbstractOperation {
     final Wei value = Wei.wrap(frame.getStackItem(0));
 
     final Address address = frame.getRecipientAddress();
-    final MutableAccount account = frame.getWorldState().getMutable(address);
+    final MutableAccount account = frame.getWorldState().getAccount(address).getMutable();
 
     frame.clearReturnData();
 
@@ -90,7 +90,8 @@ public abstract class AbstractCreateOperation extends AbstractOperation {
 
   private void spawnChildMessage(final MessageFrame frame) {
     final Address address = frame.getRecipientAddress();
-    final MutableAccount account = frame.getWorldState().getMutable(address);
+    final MutableAccount account = frame.getWorldState().getAccount(address).getMutable();
+
     account.incrementNonce();
 
     final Wei value = Wei.wrap(frame.getStackItem(0));

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperation.java

@@ -53,7 +53,8 @@ public class SStoreOperation extends AbstractOperation {
     final UInt256 key = frame.popStackItem().asUInt256();
     final UInt256 value = frame.popStackItem().asUInt256();
 
-    final MutableAccount account = frame.getWorldState().getMutable(frame.getRecipientAddress());
+    final MutableAccount account =
+        frame.getWorldState().getAccount(frame.getRecipientAddress()).getMutable();
     assert account != null : "VM account should exists";
 
     // Increment the refund counter.

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SelfDestructOperation.java

@@ -48,12 +48,12 @@ public class SelfDestructOperation extends AbstractOperation {
   @Override
   public void execute(final MessageFrame frame) {
     final Address address = frame.getRecipientAddress();
-    final MutableAccount account = frame.getWorldState().getMutable(address);
+    final MutableAccount account = frame.getWorldState().getAccount(address).getMutable();
 
     frame.addSelfDestruct(address);
 
     final MutableAccount recipient =
-        frame.getWorldState().getOrCreate(Words.toAddress(frame.popStackItem()));
+        frame.getWorldState().getOrCreate(Words.toAddress(frame.popStackItem())).getMutable();
 
     recipient.incrementBalance(account.getBalance());
 

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutablePrivateWorldStateUpdater.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright ConsenSys AG.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package org.hyperledger.besu.ethereum.worldstate;
+
+import org.hyperledger.besu.ethereum.core.Account;
+import org.hyperledger.besu.ethereum.core.Address;
+import org.hyperledger.besu.ethereum.core.DefaultEvmAccount;
+import org.hyperledger.besu.ethereum.core.Wei;
+import org.hyperledger.besu.ethereum.core.WorldUpdater;
+
+import java.util.Collection;
+
+public class DefaultMutablePrivateWorldStateUpdater implements WorldUpdater {
+
+  private final WorldUpdater publicWorldUpdater;
+  private final WorldUpdater privateWorldUpdater;
+
+  public DefaultMutablePrivateWorldStateUpdater(
+      final WorldUpdater publicWorldUpdater, final WorldUpdater privateWorldUpdater) {
+    this.publicWorldUpdater = publicWorldUpdater;
+    this.privateWorldUpdater = privateWorldUpdater;
+  }
+
+  @Override
+  public DefaultEvmAccount createAccount(
+      final Address address, final long nonce, final Wei balance) {
+    return privateWorldUpdater.createAccount(address);
+  }
+
+  @Override
+  public DefaultEvmAccount createAccount(final Address address) {
+    return privateWorldUpdater.createAccount(address);
+  }
+
+  @Override
+  public DefaultEvmAccount getOrCreate(final Address address) {
+    return privateWorldUpdater.getOrCreate(address);
+  }
+
+  @Override
+  public DefaultEvmAccount getAccount(final Address address) {
+    final DefaultEvmAccount privateAccount = privateWorldUpdater.getAccount(address);
+    if (privateAccount != null && !privateAccount.isEmpty()) {
+      return privateAccount;
+    }
+    final DefaultEvmAccount publicAccount = publicWorldUpdater.getAccount(address);
+    if (publicAccount != null && !publicAccount.isEmpty()) {
+      publicAccount.setImmutable(true);
+      return publicAccount;
+    }
+    return null;
+  }
+
+  @Override
+  public void deleteAccount(final Address address) {
+    privateWorldUpdater.deleteAccount(address);
+  }
+
+  @Override
+  public Collection<Account> getTouchedAccounts() {
+    return privateWorldUpdater.getTouchedAccounts();
+  }
+
+  @Override
+  public void revert() {
+    privateWorldUpdater.revert();
+  }
+
+  @Override
+  public void commit() {
+    privateWorldUpdater.commit();
+  }
+
+  @Override
+  public Account get(final Address address) {
+    final Account privateAccount = privateWorldUpdater.get(address);
+    if (privateAccount != null && !privateAccount.isEmpty()) {
+      return privateAccount;
+    }
+    return publicWorldUpdater.get(address);
+  }
+
+  @Override
+  public WorldUpdater updater() {
+    return this;
+  }
+}

ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/BlockDataGenerator.java

@@ -111,7 +111,7 @@ public class BlockDataGenerator {
         // Mutate accounts
         accountsToSetup.forEach(
             hash -> {
-              final MutableAccount a = stateUpdater.getMutable(hash);
+              final MutableAccount a = stateUpdater.getAccount(hash).getMutable();
               a.incrementNonce();
               a.setBalance(Wei.of(positiveLong()));
               storageKeys.forEach(key -> a.setStorageValue(key, UInt256.ONE));
@@ -150,7 +150,7 @@ public class BlockDataGenerator {
     WorldUpdater updater = worldState.updater();
     List<Account> accounts = new ArrayList<>(count);
     for (int i = 0; i < count; i++) {
-      MutableAccount account = updater.getOrCreate(address());
+      MutableAccount account = updater.getOrCreate(address()).getMutable();
       if (random.nextFloat() < percentContractAccounts) {
         // Some percentage of accounts are contract accounts
         account.setCode(bytesValue(5, 50));

ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TestCodeExecutor.java

@@ -95,7 +95,8 @@ public class TestCodeExecutor {
     final MutableWorldState initialWorldState = stateArchive.getMutable();
 
     final WorldUpdater worldState = initialWorldState.updater();
-    final MutableAccount senderAccount = worldState.getOrCreate(TestCodeExecutor.SENDER_ADDRESS);
+    final MutableAccount senderAccount =
+        worldState.getOrCreate(TestCodeExecutor.SENDER_ADDRESS).getMutable();
     accountSetup.accept(senderAccount);
     worldState.commit();
     initialWorldState.persist();

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracerTest.java

@@ -22,6 +22,7 @@ import static org.mockito.Mockito.when;
 
 import org.hyperledger.besu.ethereum.core.BlockHeader;
 import org.hyperledger.besu.ethereum.core.BlockHeaderTestFixture;
+import org.hyperledger.besu.ethereum.core.DefaultEvmAccount;
 import org.hyperledger.besu.ethereum.core.Gas;
 import org.hyperledger.besu.ethereum.core.MessageFrameTestFixture;
 import org.hyperledger.besu.ethereum.core.MutableAccount;
@@ -212,13 +213,15 @@ public class DebugOperationTracerTest {
   }
 
   private Map<UInt256, UInt256> setupStorageForCapture(final MessageFrame frame) {
-    final MutableAccount account = mock(MutableAccount.class);
-    when(worldUpdater.getMutable(frame.getRecipientAddress())).thenReturn(account);
+    final DefaultEvmAccount account = mock(DefaultEvmAccount.class);
+    final MutableAccount mutableAccount = mock(MutableAccount.class);
+    when(account.getMutable()).thenReturn(mutableAccount);
+    when(worldUpdater.getAccount(frame.getRecipientAddress())).thenReturn(account);
 
     final Map<UInt256, UInt256> updatedStorage = new TreeMap<>();
     updatedStorage.put(UInt256.ZERO, UInt256.of(233));
     updatedStorage.put(UInt256.ONE, UInt256.of(2424));
-    when(account.getUpdatedStorage()).thenReturn(updatedStorage);
+    when(mutableAccount.getUpdatedStorage()).thenReturn(updatedStorage);
     final Bytes32 word1 = Bytes32.fromHexString("0x01");
     final Bytes32 word2 = Bytes32.fromHexString("0x02");
     final Bytes32 word3 = Bytes32.fromHexString("0x03");

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/WorldStateMock.java

@@ -89,7 +89,7 @@ public class WorldStateMock extends DefaultMutableWorldState {
 
   public static void insertAccount(
       final WorldUpdater updater, final Address address, final AccountMock toCopy) {
-    final MutableAccount account = updater.getOrCreate(address);
+    final MutableAccount account = updater.getOrCreate(address).getMutable();
     account.setNonce(toCopy.getNonce());
     account.setBalance(toCopy.getBalance());
     account.setCode(toCopy.getCode());

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/ExtCodeHashOperationTest.java

@@ -74,7 +74,7 @@ public class ExtCodeHashOperationTest {
 
   @Test
   public void shouldReturnHashOfEmptyDataWhenAccountExistsButDoesNotHaveCode() {
-    worldStateUpdater.getOrCreate(REQUESTED_ADDRESS).setBalance(Wei.of(1));
+    worldStateUpdater.getOrCreate(REQUESTED_ADDRESS).getMutable().setBalance(Wei.of(1));
     assertThat(executeOperation(REQUESTED_ADDRESS)).isEqualTo(Hash.EMPTY);
   }
 
@@ -92,14 +92,14 @@ public class ExtCodeHashOperationTest {
   @Test
   public void shouldReturnEmptyCodeHashWhenPrecompileHasBalance() {
     // Sending money to a precompile causes it to exist in the world state archive.
-    worldStateUpdater.getOrCreate(Address.ECREC).setBalance(Wei.of(10));
+    worldStateUpdater.getOrCreate(Address.ECREC).getMutable().setBalance(Wei.of(10));
     assertThat(executeOperation(Address.ECREC)).isEqualTo(Hash.EMPTY);
   }
 
   @Test
   public void shouldGetHashOfAccountCodeWhenCodeIsPresent() {
     final BytesValue code = BytesValue.fromHexString("0xabcdef");
-    final MutableAccount account = worldStateUpdater.getOrCreate(REQUESTED_ADDRESS);
+    final MutableAccount account = worldStateUpdater.getOrCreate(REQUESTED_ADDRESS).getMutable();
     account.setCode(code);
     account.setVersion(Account.DEFAULT_VERSION);
     assertThat(executeOperation(REQUESTED_ADDRESS)).isEqualTo(Hash.hash(code));
@@ -109,7 +109,7 @@ public class ExtCodeHashOperationTest {
   public void shouldZeroOutLeftMostBitsToGetAddress() {
     // If EXTCODEHASH of A is X, then EXTCODEHASH of A + 2**160 is X.
     final BytesValue code = BytesValue.fromHexString("0xabcdef");
-    final MutableAccount account = worldStateUpdater.getOrCreate(REQUESTED_ADDRESS);
+    final MutableAccount account = worldStateUpdater.getOrCreate(REQUESTED_ADDRESS).getMutable();
     account.setCode(code);
     account.setVersion(Account.DEFAULT_VERSION);
     final Bytes32 value =

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperationTest.java

@@ -103,7 +103,7 @@ public class SStoreOperationTest {
             .blockchain(blockchain)
             .initialGas(initialGas)
             .build();
-    worldStateUpdater.getOrCreate(address).setBalance(Wei.of(1));
+    worldStateUpdater.getOrCreate(address).getMutable().setBalance(Wei.of(1));
     worldStateUpdater.commit();
     frame.setGasRemaining(remainingGas);
 

ethereum/core/src/test/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutableWorldStateTest.java

@@ -83,7 +83,7 @@ public class DefaultMutableWorldStateTest {
   public void containsAccount_AccountExists() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.commit();
     assertThat(worldState.get(ADDRESS)).isNotNull();
     assertThat(worldState.rootHash())
@@ -108,7 +108,7 @@ public class DefaultMutableWorldStateTest {
   public void removeAccount_UpdatedAccount() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.deleteAccount(ADDRESS);
     updater.commit();
     assertThat(worldState.rootHash()).isEqualTo(MerklePatriciaTrie.EMPTY_TRIE_NODE_HASH);
@@ -122,7 +122,7 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.commit();
     assertThat(worldState.get(ADDRESS)).isNotNull();
     assertThat(worldState.rootHash()).isNotEqualTo(MerklePatriciaTrie.EMPTY_TRIE_NODE_HASH);
@@ -131,7 +131,7 @@ public class DefaultMutableWorldStateTest {
     updater = worldState.updater();
     updater.deleteAccount(ADDRESS);
     assertThat(updater.get(ADDRESS)).isNull();
-    assertThat(updater.getMutable(ADDRESS)).isNull();
+    assertThat(updater.getAccount(ADDRESS)).isNull();
     updater.commit();
     assertThat(updater.get(ADDRESS)).isNull();
 
@@ -143,7 +143,7 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.commit();
     worldState.persist();
     assertThat(worldState.get(ADDRESS)).isNotNull();
@@ -153,7 +153,7 @@ public class DefaultMutableWorldStateTest {
     updater = worldState.updater();
     updater.deleteAccount(ADDRESS);
     assertThat(updater.get(ADDRESS)).isNull();
-    assertThat(updater.getMutable(ADDRESS)).isNull();
+    assertThat(updater.getAccount(ADDRESS)).isNull();
     // Check account is gone after committing
     updater.commit();
     assertThat(updater.get(ADDRESS)).isNull();
@@ -175,7 +175,7 @@ public class DefaultMutableWorldStateTest {
   public void streamAccounts_singleAccount() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.commit();
 
     List<StreamableAccount> accounts =
@@ -201,10 +201,10 @@ public class DefaultMutableWorldStateTest {
     final WorldUpdater updater = worldState.updater();
 
     // Create an account
-    final MutableAccount accountA = updater.createAccount(addr1);
+    final MutableAccount accountA = updater.createAccount(addr1).getMutable();
     accountA.setBalance(Wei.of(100000));
     // Create another
-    final MutableAccount accountB = updater.createAccount(addr2);
+    final MutableAccount accountB = updater.createAccount(addr2).getMutable();
     accountB.setNonce(1);
     // Commit changes
     updater.commit();
@@ -249,7 +249,7 @@ public class DefaultMutableWorldStateTest {
         Hash.fromHexString("0xa3e1c133a5a51b03399ed9ad0380f3182e9e18322f232b816dd4b9094f871e1b");
 
     // Update account and assert we get the expected response from updater
-    updater.createAccount(ADDRESS).setBalance(newBalance);
+    updater.createAccount(ADDRESS).getMutable().setBalance(newBalance);
     assertThat(updater.get(ADDRESS)).isNotNull();
     assertThat(updater.get(ADDRESS).getBalance()).isEqualTo(newBalance);
 
@@ -285,7 +285,7 @@ public class DefaultMutableWorldStateTest {
   public void getAccountNonce_AccountExists() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setNonce(1L);
+    updater.createAccount(ADDRESS).getMutable().setNonce(1L);
     updater.commit();
     assertThat(worldState.get(ADDRESS).getNonce()).isEqualTo(1L);
     assertThat(worldState.rootHash())
@@ -298,7 +298,7 @@ public class DefaultMutableWorldStateTest {
   public void replaceAccountNonce() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setNonce(1L);
     account.setNonce(2L);
     updater.commit();
@@ -313,7 +313,7 @@ public class DefaultMutableWorldStateTest {
   public void getAccountBalance_AccountExists() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    updater.createAccount(ADDRESS).setBalance(Wei.of(100000));
+    updater.createAccount(ADDRESS).getMutable().setBalance(Wei.of(100000));
     updater.commit();
     assertThat(worldState.get(ADDRESS).getBalance()).isEqualTo(Wei.of(100000));
   }
@@ -322,7 +322,7 @@ public class DefaultMutableWorldStateTest {
   public void replaceAccountBalance() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setBalance(Wei.of(200000));
     updater.commit();
@@ -337,7 +337,7 @@ public class DefaultMutableWorldStateTest {
   public void setStorageValue_ZeroValue() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(UInt256.ZERO, UInt256.ZERO);
     updater.commit();
@@ -352,7 +352,7 @@ public class DefaultMutableWorldStateTest {
   public void setStorageValue_NonzeroValue() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(UInt256.ONE, UInt256.of(2));
     updater.commit();
@@ -367,7 +367,7 @@ public class DefaultMutableWorldStateTest {
   public void replaceStorageValue_NonzeroValue() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(UInt256.ONE, UInt256.of(2));
     account.setStorageValue(UInt256.ONE, UInt256.of(3));
@@ -383,7 +383,7 @@ public class DefaultMutableWorldStateTest {
   public void replaceStorageValue_ZeroValue() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(UInt256.ONE, UInt256.of(2));
     account.setStorageValue(UInt256.ONE, UInt256.ZERO);
@@ -398,12 +398,12 @@ public class DefaultMutableWorldStateTest {
   public void getOriginalStorageValue() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater setupUpdater = worldState.updater();
-    final MutableAccount setupAccount = setupUpdater.createAccount(ADDRESS);
+    final MutableAccount setupAccount = setupUpdater.createAccount(ADDRESS).getMutable();
     setupAccount.setStorageValue(UInt256.ONE, UInt256.of(2));
     setupUpdater.commit();
 
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.getOrCreate(ADDRESS);
+    final MutableAccount account = updater.getOrCreate(ADDRESS).getMutable();
     assertThat(account.getOriginalStorageValue(UInt256.ONE)).isEqualTo(UInt256.of(2));
 
     account.setStorageValue(UInt256.ONE, UInt256.of(3));
@@ -414,12 +414,12 @@ public class DefaultMutableWorldStateTest {
   public void originalStorageValueIsAlwaysZeroIfStorageWasCleared() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater setupUpdater = worldState.updater();
-    final MutableAccount setupAccount = setupUpdater.createAccount(ADDRESS);
+    final MutableAccount setupAccount = setupUpdater.createAccount(ADDRESS).getMutable();
     setupAccount.setStorageValue(UInt256.ONE, UInt256.of(2));
     setupUpdater.commit();
 
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.getOrCreate(ADDRESS);
+    final MutableAccount account = updater.getOrCreate(ADDRESS).getMutable();
 
     account.clearStorage();
     assertThat(account.getOriginalStorageValue(UInt256.ONE)).isEqualTo(UInt256.ZERO);
@@ -433,13 +433,13 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.createAccount(ADDRESS);
+    MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(storageKey, storageValue);
     assertThat(account.getStorageValue(storageKey)).isEqualTo(storageValue);
 
     // Clear storage
-    account = updater.getMutable(ADDRESS);
+    account = updater.getAccount(ADDRESS).getMutable();
     assertThat(account).isNotNull();
     assertThat(account.getStorageValue(storageKey)).isEqualTo(storageValue);
     account.clearStorage();
@@ -448,12 +448,12 @@ public class DefaultMutableWorldStateTest {
 
     // Check storage is cleared after committing
     updater.commit();
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
 
     // And after persisting
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
   }
@@ -466,7 +466,7 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.createAccount(ADDRESS);
+    MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(storageKey, storageValue);
     updater.commit();
@@ -475,7 +475,7 @@ public class DefaultMutableWorldStateTest {
     assertThat(worldState.rootHash()).isNotEqualTo(MerklePatriciaTrie.EMPTY_TRIE_NODE_HASH);
 
     // Clear storage
-    account = updater.getMutable(ADDRESS);
+    account = updater.getAccount(ADDRESS).getMutable();
     assertThat(account).isNotNull();
     assertThat(account.getStorageValue(storageKey)).isEqualTo(storageValue);
     account.clearStorage();
@@ -485,12 +485,12 @@ public class DefaultMutableWorldStateTest {
 
     // Check storage is cleared after committing
     updater.commit();
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
 
     // And after persisting
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(UInt256.ZERO);
   }
@@ -504,13 +504,13 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.createAccount(ADDRESS);
+    MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(storageKey, originalStorageValue);
     assertThat(account.getStorageValue(storageKey)).isEqualTo(originalStorageValue);
 
     // Clear storage then edit
-    account = updater.getMutable(ADDRESS);
+    account = updater.getAccount(ADDRESS).getMutable();
     assertThat(account).isNotNull();
     assertThat(account.getStorageValue(storageKey)).isEqualTo(originalStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(originalStorageValue);
@@ -520,12 +520,12 @@ public class DefaultMutableWorldStateTest {
 
     // Check storage is cleared after committing
     updater.commit();
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
 
     // And after persisting
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
   }
@@ -539,7 +539,7 @@ public class DefaultMutableWorldStateTest {
     // Create a world state with one account
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.createAccount(ADDRESS);
+    MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(storageKey, originalStorageValue);
     assertThat(account.getStorageValue(storageKey)).isEqualTo(originalStorageValue);
@@ -547,7 +547,7 @@ public class DefaultMutableWorldStateTest {
     worldState.persist();
 
     // Clear storage then edit
-    account = updater.getMutable(ADDRESS);
+    account = updater.getAccount(ADDRESS).getMutable();
     assertThat(account).isNotNull();
     assertThat(account.getStorageValue(storageKey)).isEqualTo(originalStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(originalStorageValue);
@@ -558,12 +558,12 @@ public class DefaultMutableWorldStateTest {
 
     // Check storage is cleared after committing
     updater.commit();
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
 
     // And after persisting
-    assertThat(updater.getMutable(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
+    assertThat(updater.getAccount(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(updater.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
     assertThat(worldState.get(ADDRESS).getStorageValue(storageKey)).isEqualTo(newStorageValue);
   }
@@ -572,7 +572,7 @@ public class DefaultMutableWorldStateTest {
   public void replaceAccountCode() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater = worldState.updater();
-    final MutableAccount account = updater.createAccount(ADDRESS);
+    final MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setCode(BytesValue.of(1, 2, 3));
     account.setVersion(Account.DEFAULT_VERSION);
@@ -590,12 +590,12 @@ public class DefaultMutableWorldStateTest {
   public void revert() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater1 = worldState.updater();
-    final MutableAccount account1 = updater1.createAccount(ADDRESS);
+    final MutableAccount account1 = updater1.createAccount(ADDRESS).getMutable();
     account1.setBalance(Wei.of(200000));
     updater1.commit();
 
     final WorldUpdater updater2 = worldState.updater();
-    final MutableAccount account2 = updater2.getMutable(ADDRESS);
+    final MutableAccount account2 = updater2.getAccount(ADDRESS).getMutable();
     account2.setBalance(Wei.of(300000));
     assertThat(updater2.get(ADDRESS).getBalance()).isEqualTo(Wei.of(300000));
 
@@ -615,7 +615,7 @@ public class DefaultMutableWorldStateTest {
   public void shouldReturnNullForGetMutableWhenAccountDeletedInAncestor() {
     final MutableWorldState worldState = createEmpty();
     final WorldUpdater updater1 = worldState.updater();
-    final MutableAccount account1 = updater1.createAccount(ADDRESS);
+    final MutableAccount account1 = updater1.createAccount(ADDRESS).getMutable();
     updater1.commit();
     assertThat(updater1.get(ADDRESS))
         .isEqualToComparingOnlyGivenFields(account1, "address", "nonce", "balance", "codeHash");
@@ -625,14 +625,14 @@ public class DefaultMutableWorldStateTest {
     assertThat(updater2.get(ADDRESS)).isEqualTo(null);
 
     final WorldUpdater updater3 = updater2.updater();
-    assertThat(updater3.getMutable(ADDRESS)).isEqualTo(null);
+    assertThat(updater3.getAccount(ADDRESS)).isEqualTo(null);
   }
 
   @Test
   public void shouldCombineUnchangedAndChangedValuesWhenRetrievingStorageEntries() {
     final MutableWorldState worldState = createEmpty();
     WorldUpdater updater = worldState.updater();
-    MutableAccount account = updater.createAccount(ADDRESS);
+    MutableAccount account = updater.createAccount(ADDRESS).getMutable();
     account.setBalance(Wei.of(100000));
     account.setStorageValue(UInt256.ONE, UInt256.of(2));
     account.setStorageValue(UInt256.of(2), UInt256.of(5));
@@ -645,7 +645,7 @@ public class DefaultMutableWorldStateTest {
     initialSetOfEntries.forEach(entry -> initialEntries.put(entry.getKeyHash(), entry));
 
     updater = worldState.updater();
-    account = updater.getMutable(ADDRESS);
+    account = updater.getAccount(ADDRESS).getMutable();
     account.setStorageValue(UInt256.ONE, UInt256.of(3));
     account.setStorageValue(UInt256.of(3), UInt256.of(6));