diff --git a/acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyAcceptanceTestBase.java b/acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyAcceptanceTestBase.java index 1a3f258bfc3..3fbb116b274 100644 --- a/acceptance-tests/dsl/src/main/java/org/hyperledger/besu/tests/acceptance/dsl/privacy/PrivacyAcceptanceTestBase.java +++ b/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.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 PrivacyAcceptanceTestBase() { privateContractTransactions = new PrivateContractTransactions(); privacyCluster = new PrivacyCluster(net); privacyAccountResolver = new PrivacyAccountResolver(); + contractTransactions = new ContractTransactions(); } @After diff --git a/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/CrossContractReader.sol b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/CrossContractReader.sol new file mode 100644 index 00000000000..32c6836433e --- /dev/null +++ b/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(); + } +} \ No newline at end of file diff --git a/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.abi b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.abi new file mode 100644 index 00000000000..36edfd6c590 --- /dev/null +++ b/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"}] \ No newline at end of file diff --git a/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.bin b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.bin new file mode 100644 index 00000000000..a18bc7505c9 --- /dev/null +++ b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.java b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/generated/CrossContractReader.java new file mode 100644 index 00000000000..9ce0c0fafd2 --- /dev/null +++ b/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. + * + *

Do not modify! + * + *

Please use the web3j command line tools, + * or the org.web3j.codegen.SolidityFunctionWrapperGenerator in the codegen module to update. + * + *

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.>asList(new TypeReference

() {}));; + + @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 remoteDestroy(String crossAddress) { + final Function function = + new Function( + FUNC_REMOTEDESTROY, + Arrays.asList(new org.web3j.abi.datatypes.Address(160, crossAddress)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public RemoteFunctionCall deployRemote(String crossAddress) { + final Function function = + new Function( + FUNC_DEPLOYREMOTE, + Arrays.asList(new org.web3j.abi.datatypes.Address(160, crossAddress)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public RemoteFunctionCall deploy() { + final Function function = + new Function(FUNC_DEPLOY, Arrays.asList(), Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public RemoteFunctionCall destroy() { + final Function function = + new Function( + FUNC_DESTROY, Arrays.asList(), Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public RemoteFunctionCall read(String emitter_address) { + final Function function = + new Function( + FUNC_READ, + Arrays.asList(new org.web3j.abi.datatypes.Address(160, emitter_address)), + Arrays.>asList(new TypeReference() {})); + return executeRemoteCallSingleValueReturn(function, BigInteger.class); + } + + public RemoteFunctionCall increment() { + final Function function = + new Function( + FUNC_INCREMENT, Arrays.asList(), Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public RemoteFunctionCall incrementRemote(String crossAddress) { + final Function function = + new Function( + FUNC_INCREMENTREMOTE, + Arrays.asList(new org.web3j.abi.datatypes.Address(160, crossAddress)), + Collections.>emptyList()); + return executeRemoteCallTransaction(function); + } + + public List getNewEventEmitterEvents( + TransactionReceipt transactionReceipt) { + List valueList = + extractEventParametersWithLog(NEWEVENTEMITTER_EVENT, transactionReceipt); + ArrayList responses = + new ArrayList(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 newEventEmitterEventFlowable(EthFilter filter) { + return web3j + .ethLogFlowable(filter) + .map( + new io.reactivex.functions.Function() { + @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 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 deploy( + Web3j web3j, Credentials credentials, ContractGasProvider contractGasProvider) { + return deployRemoteCall( + CrossContractReader.class, web3j, credentials, contractGasProvider, BINARY, ""); + } + + @Deprecated + public static RemoteCall deploy( + Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) { + return deployRemoteCall( + CrossContractReader.class, web3j, credentials, gasPrice, gasLimit, BINARY, ""); + } + + public static RemoteCall deploy( + Web3j web3j, TransactionManager transactionManager, ContractGasProvider contractGasProvider) { + return deployRemoteCall( + CrossContractReader.class, web3j, transactionManager, contractGasProvider, BINARY, ""); + } + + @Deprecated + public static RemoteCall 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; + } +} diff --git a/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/privacy/PrivateContractPublicStateAcceptanceTest.java b/acceptance-tests/tests/src/test/java/org/hyperledger/besu/tests/web3j/privacy/PrivateContractPublicStateAcceptanceTest.java new file mode 100644 index 00000000000..2672d24faf7 --- /dev/null +++ b/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"); + } +} diff --git a/ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java b/ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java index 46c48fa1939..aa2ff3820c3 100644 --- a/ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java +++ b/ethereum/blockcreation/src/main/java/org/hyperledger/besu/ethereum/blockcreation/AbstractBlockCreator.java @@ -21,8 +21,8 @@ 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 @@ boolean rewardBeneficiary( } 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 @@ boolean rewardBeneficiary( 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(); diff --git a/ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/EntriesFromIntegrationTest.java b/ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/EntriesFromIntegrationTest.java index 81b29832532..bc7692106b5 100644 --- a/ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/EntriesFromIntegrationTest.java +++ b/ethereum/core/src/integration-test/java/org/hyperledger/besu/ethereum/vm/EntriesFromIntegrationTest.java @@ -40,7 +40,7 @@ public void shouldCollectStateEntries() { 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 expectedValues = new TreeMap<>(); final int nodeCount = 100_000; final Random random = new Random(42989428249L); @@ -53,7 +53,7 @@ public void shouldCollectStateEntries() { 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)); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/GenesisState.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/GenesisState.java index e3ee8416634..01800216a9a 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/GenesisState.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/chain/GenesisState.java @@ -112,7 +112,7 @@ private static void writeAccountsTo( 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); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/AbstractWorldUpdater.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/AbstractWorldUpdater.java index 54cbc99e02d..35e5bd46443 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/AbstractWorldUpdater.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/AbstractWorldUpdater.java @@ -59,11 +59,12 @@ protected UpdateTrackingAccount track(final UpdateTrackingAccount account) } @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 account = new UpdateTrackingAccount<>(address); account.setNonce(nonce); account.setBalance(balance); - return track(account); + return new DefaultEvmAccount(track(account)); } @Override @@ -80,11 +81,11 @@ public Account get(final Address address) { } @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 MutableAccount getMutable(final Address address) { if (origin == null) { return null; } else { - return track(new UpdateTrackingAccount<>(origin)); + return new DefaultEvmAccount(track(new UpdateTrackingAccount<>(origin))); } } diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/DefaultEvmAccount.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/DefaultEvmAccount.java new file mode 100644 index 00000000000..c8d696ba707 --- /dev/null +++ b/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 storageEntriesFrom( + final Bytes32 startKeyHash, final int limit) { + return mutableAccount.storageEntriesFrom(startKeyHash, limit); + } +} diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/EvmAccount.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/EvmAccount.java new file mode 100644 index 00000000000..26621f29887 --- /dev/null +++ b/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; +} diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/ModificationNotAllowedException.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/ModificationNotAllowedException.java new file mode 100644 index 00000000000..9d746379960 --- /dev/null +++ b/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"); + } +} diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/WorldUpdater.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/WorldUpdater.java index b4e52b3d422..84eda68aa0e 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/WorldUpdater.java +++ b/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 @@ default MutableAccount createAccount(final Address address) { * * @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 @@ default MutableAccount getOrCreate(final Address address) { * 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. diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java index bd4706c10f7..c2eac45c10b 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java @@ -167,7 +167,7 @@ private boolean rewardCoinbase( } 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 @@ private boolean rewardCoinbase( 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); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetContractCreationProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetContractCreationProcessor.java index 9d19b14c618..0edf89f0a9c 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetContractCreationProcessor.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetContractCreationProcessor.java @@ -17,6 +17,7 @@ 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,21 +106,27 @@ public void start(final MessageFrame frame) { if (LOG.isTraceEnabled()) { LOG.trace("Executing contract-creation"); } - - final MutableAccount sender = frame.getWorldState().getMutable(frame.getSenderAddress()); - sender.decrementBalance(frame.getValue()); - - final MutableAccount contract = frame.getWorldState().getOrCreate(frame.getContractAddress()); - if (accountExists(contract)) { - LOG.trace( - "Contract creation error: account as already been created for address {}", - frame.getContractAddress()); + try { + final MutableAccount sender = + frame.getWorldState().getAccount(frame.getSenderAddress()).getMutable(); + sender.decrementBalance(frame.getValue()); + + final MutableAccount contract = + frame.getWorldState().getOrCreate(frame.getContractAddress()).getMutable(); + if (accountExists(contract)) { + LOG.trace( + "Contract creation error: account as already been created for address {}", + frame.getContractAddress()); + frame.setState(MessageFrame.State.EXCEPTIONAL_HALT); + } else { + contract.incrementBalance(frame.getValue()); + contract.setNonce(initialContractNonce); + 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); - } else { - contract.incrementBalance(frame.getValue()); - contract.setNonce(initialContractNonce); - contract.clearStorage(); - frame.setState(MessageFrame.State.CODE_EXECUTING); } } @@ -148,7 +155,7 @@ protected void codeSuccess(final MessageFrame frame) { // 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( diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetMessageCallProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetMessageCallProcessor.java index 72c596ca766..3c794a7424c 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetMessageCallProcessor.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetMessageCallProcessor.java @@ -16,6 +16,7 @@ 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,16 +50,20 @@ public MainnetMessageCallProcessor(final EVM evm, final PrecompileContractRegist @Override public void start(final MessageFrame frame) { LOG.trace("Executing message-call"); + try { + transferValue(frame); - transferValue(frame); - - // Check first if the message call is to a pre-compile contract - final PrecompiledContract precompile = - precompiles.get(frame.getContractAddress(), frame.getContractAccountVersion()); - if (precompile != null) { - executePrecompile(precompile, frame); - } else { - frame.setState(MessageFrame.State.CODE_EXECUTING); + // Check first if the message call is to a pre-compile contract + final PrecompiledContract precompile = + precompiles.get(frame.getContractAddress(), frame.getContractAccountVersion()); + if (precompile != null) { + executePrecompile(precompile, frame); + } 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); } } @@ -79,11 +84,12 @@ protected void codeSuccess(final MessageFrame frame) { * 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()); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java index 96c76437764..6b2f0be1290 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java @@ -370,9 +370,9 @@ private void updateWorldStateForDao(final MutableWorldState worldState) { .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); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java index 36a0cbba9e8..05989d34356 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java @@ -17,6 +17,7 @@ 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 Result processTransaction( } 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 Result processTransaction( 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 Result processTransaction( 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); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionProcessor.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionProcessor.java index 1a37d47fc5a..4d26de9f517 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionProcessor.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/privacy/PrivateTransactionProcessor.java @@ -17,6 +17,7 @@ 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.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 Result processTransaction( 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 validationResult = privateTransactionValidator.validate(transaction, sender.getNonce()); @@ -211,6 +213,10 @@ public Result processTransaction( final MessageFrame initialFrame; final Deque 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 Result processTransaction( .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 Result processTransaction( .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 Result processTransaction( } if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) { - privateWorldState.commit(); + mutablePrivateWorldStateUpdater.commit(); } if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) { diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracer.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracer.java index 7c411cb7a81..31ddad3cd17 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracer.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracer.java @@ -18,6 +18,7 @@ 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 @@ private Optional> captureStorage(final MessageFrame frame) if (!options.isStorageEnabled()) { return Optional.empty(); } - final Map storageContents = - new TreeMap<>( - frame.getWorldState().getMutable(frame.getRecipientAddress()).getUpdatedStorage()); - return Optional.of(storageContents); + try { + final Map storageContents = + new TreeMap<>( + frame + .getWorldState() + .getAccount(frame.getRecipientAddress()) + .getMutable() + .getUpdatedStorage()); + return Optional.of(storageContents); + } catch (ModificationNotAllowedException e) { + return Optional.of(new TreeMap<>()); + } } private Optional captureMemory(final MessageFrame frame) { diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/AbstractCreateOperation.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/AbstractCreateOperation.java index 9cbfdb64a7c..ca116165b13 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/AbstractCreateOperation.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/AbstractCreateOperation.java @@ -57,7 +57,7 @@ public void execute(final MessageFrame frame) { 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 @@ private void fail(final MessageFrame frame) { 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)); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperation.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperation.java index 93cbf80495c..ba8ff3b629e 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperation.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperation.java @@ -53,7 +53,8 @@ public void execute(final MessageFrame frame) { 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. diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SelfDestructOperation.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SelfDestructOperation.java index bd64f999569..54e00615cea 100644 --- a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SelfDestructOperation.java +++ b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/vm/operations/SelfDestructOperation.java @@ -48,12 +48,12 @@ public Gas cost(final MessageFrame frame) { @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()); diff --git a/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutablePrivateWorldStateUpdater.java b/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutablePrivateWorldStateUpdater.java new file mode 100644 index 00000000000..4a0152e1096 --- /dev/null +++ b/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 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; + } +} diff --git a/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/BlockDataGenerator.java b/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/BlockDataGenerator.java index 3a1665ff7c8..020aafa509d 100644 --- a/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/BlockDataGenerator.java +++ b/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/BlockDataGenerator.java @@ -111,7 +111,7 @@ private List blockSequence( // 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 @@ private List createRandomAccounts( WorldUpdater updater = worldState.updater(); List 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)); diff --git a/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TestCodeExecutor.java b/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TestCodeExecutor.java index ccf46fe5e82..0cff6b3a4d7 100644 --- a/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TestCodeExecutor.java +++ b/ethereum/core/src/test-support/java/org/hyperledger/besu/ethereum/core/TestCodeExecutor.java @@ -95,7 +95,8 @@ private WorldUpdater createInitialWorldState( 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(); diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracerTest.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracerTest.java index ea228db66a5..001dedc09fd 100644 --- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracerTest.java +++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/DebugOperationTracerTest.java @@ -22,6 +22,7 @@ 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 @@ private MessageFrameTestFixture validMessageFrameBuilder() { } private Map 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 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"); diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/WorldStateMock.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/WorldStateMock.java index 140170b9369..a357349dd22 100644 --- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/WorldStateMock.java +++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/WorldStateMock.java @@ -89,7 +89,7 @@ public Map getStorage() { 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()); diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/ExtCodeHashOperationTest.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/ExtCodeHashOperationTest.java index 36cd3944f60..8f0080d10d0 100644 --- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/ExtCodeHashOperationTest.java +++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/ExtCodeHashOperationTest.java @@ -74,7 +74,7 @@ public void shouldReturnZeroWhenAccountDoesNotExist() { @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 void shouldReturnZeroWhenPrecompiledContractHasNoBalance() { @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 void shouldGetHashOfAccountCodeWhenCodeIsPresent() { 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 = diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperationTest.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperationTest.java index 0f2f8055d8a..1a0eaf5f11a 100644 --- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperationTest.java +++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/vm/operations/SStoreOperationTest.java @@ -103,7 +103,7 @@ private MessageFrame createMessageFrame( .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); diff --git a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutableWorldStateTest.java b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutableWorldStateTest.java index c7a6ef29542..2b2ef187746 100644 --- a/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutableWorldStateTest.java +++ b/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/worldstate/DefaultMutableWorldStateTest.java @@ -83,7 +83,7 @@ public void containsAccount_AccountDoesNotExist() { 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 void removeAccount_AccountDoesNotExist() { 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 void removeAccount_AccountExists() { // 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 void removeAccount_AccountExists() { 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 void removeAccount_AccountExistsAndIsPersisted() { // 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 void removeAccount_AccountExistsAndIsPersisted() { 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 void streamAccounts_empty() { 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 accounts = @@ -201,10 +201,10 @@ public void streamAccounts_multipleAccounts() { 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 void commitAndPersist() { 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 void commitAndPersist() { 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 void getAccountNonce_AccountExists() { 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 void replaceAccountNonce() { 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 void getAccountBalance_AccountExists() { 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 void replaceAccountBalance() { 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 void setStorageValue_ZeroValue() { 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 void setStorageValue_NonzeroValue() { 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 void replaceStorageValue_NonzeroValue() { 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 void replaceStorageValue_ZeroValue() { 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 void getOriginalStorageValue() { 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 void clearStorage() { // 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 void clearStorage() { // 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 void clearStorage_AfterPersisting() { // 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 void clearStorage_AfterPersisting() { 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 void clearStorage_AfterPersisting() { // 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 void clearStorageThenEdit() { // 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 void clearStorageThenEdit() { // 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 void clearStorageThenEditAfterPersisting() { // 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 void clearStorageThenEditAfterPersisting() { 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 void clearStorageThenEditAfterPersisting() { // 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 void clearStorageThenEditAfterPersisting() { 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 void replaceAccountCode() { 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 void revert() { 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 void shouldReturnNullForGetMutableWhenAccountDeletedInAncestor() { 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 void shouldCombineUnchangedAndChangedValuesWhenRetrievingStorageEntries() 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));