|
|
|
@ -14,7 +14,7 @@ |
|
|
|
* |
|
|
|
* |
|
|
|
*/ |
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
package org.hyperledger.besu.ethereum.trie.bonsai.worldview; |
|
|
|
package org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator; |
|
|
|
|
|
|
|
|
|
|
|
import org.hyperledger.besu.datatypes.AccountValue; |
|
|
|
import org.hyperledger.besu.datatypes.AccountValue; |
|
|
|
import org.hyperledger.besu.datatypes.Address; |
|
|
|
import org.hyperledger.besu.datatypes.Address; |
|
|
|
@ -23,9 +23,15 @@ import org.hyperledger.besu.datatypes.StorageSlotKey; |
|
|
|
import org.hyperledger.besu.datatypes.Wei; |
|
|
|
import org.hyperledger.besu.datatypes.Wei; |
|
|
|
import org.hyperledger.besu.ethereum.rlp.RLP; |
|
|
|
import org.hyperledger.besu.ethereum.rlp.RLP; |
|
|
|
import org.hyperledger.besu.ethereum.trie.MerkleTrieException; |
|
|
|
import org.hyperledger.besu.ethereum.trie.MerkleTrieException; |
|
|
|
import org.hyperledger.besu.ethereum.trie.bonsai.BonsaiAccount; |
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.BonsaiAccount; |
|
|
|
import org.hyperledger.besu.ethereum.trie.bonsai.BonsaiValue; |
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState; |
|
|
|
import org.hyperledger.besu.ethereum.trie.bonsai.storage.BonsaiWorldStateKeyValueStorage; |
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedAccount; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.DiffBasedValue; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.storage.DiffBasedWorldStateKeyValueStorage; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.DiffBasedWorldView; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.AccountConsumingMap; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.Consumer; |
|
|
|
|
|
|
|
import org.hyperledger.besu.ethereum.trie.diffbased.common.worldview.accumulator.preload.StorageConsumingMap; |
|
|
|
import org.hyperledger.besu.evm.account.Account; |
|
|
|
import org.hyperledger.besu.evm.account.Account; |
|
|
|
import org.hyperledger.besu.evm.account.MutableAccount; |
|
|
|
import org.hyperledger.besu.evm.account.MutableAccount; |
|
|
|
import org.hyperledger.besu.evm.internal.EvmConfiguration; |
|
|
|
import org.hyperledger.besu.evm.internal.EvmConfiguration; |
|
|
|
@ -44,41 +50,39 @@ import java.util.Optional; |
|
|
|
import java.util.Set; |
|
|
|
import java.util.Set; |
|
|
|
import java.util.TreeSet; |
|
|
|
import java.util.TreeSet; |
|
|
|
import java.util.concurrent.ConcurrentHashMap; |
|
|
|
import java.util.concurrent.ConcurrentHashMap; |
|
|
|
import java.util.concurrent.ConcurrentMap; |
|
|
|
|
|
|
|
import java.util.function.Function; |
|
|
|
import java.util.function.Function; |
|
|
|
|
|
|
|
|
|
|
|
import com.google.common.collect.ForwardingMap; |
|
|
|
|
|
|
|
import org.apache.tuweni.bytes.Bytes; |
|
|
|
import org.apache.tuweni.bytes.Bytes; |
|
|
|
import org.apache.tuweni.bytes.Bytes32; |
|
|
|
import org.apache.tuweni.bytes.Bytes32; |
|
|
|
import org.apache.tuweni.units.bigints.UInt256; |
|
|
|
import org.apache.tuweni.units.bigints.UInt256; |
|
|
|
import org.jetbrains.annotations.NotNull; |
|
|
|
|
|
|
|
import org.slf4j.Logger; |
|
|
|
import org.slf4j.Logger; |
|
|
|
import org.slf4j.LoggerFactory; |
|
|
|
import org.slf4j.LoggerFactory; |
|
|
|
|
|
|
|
|
|
|
|
public class BonsaiWorldStateUpdateAccumulator |
|
|
|
@SuppressWarnings("unchecked") |
|
|
|
extends AbstractWorldUpdater<BonsaiWorldView, BonsaiAccount> |
|
|
|
public abstract class DiffBasedWorldStateUpdateAccumulator<ACCOUNT extends DiffBasedAccount> |
|
|
|
implements BonsaiWorldView, TrieLogAccumulator { |
|
|
|
extends AbstractWorldUpdater<DiffBasedWorldView, ACCOUNT> |
|
|
|
|
|
|
|
implements DiffBasedWorldView, TrieLogAccumulator { |
|
|
|
private static final Logger LOG = |
|
|
|
private static final Logger LOG = |
|
|
|
LoggerFactory.getLogger(BonsaiWorldStateUpdateAccumulator.class); |
|
|
|
LoggerFactory.getLogger(DiffBasedWorldStateUpdateAccumulator.class); |
|
|
|
private final Consumer<BonsaiValue<BonsaiAccount>> accountPreloader; |
|
|
|
private final Consumer<DiffBasedValue<ACCOUNT>> accountPreloader; |
|
|
|
private final Consumer<StorageSlotKey> storagePreloader; |
|
|
|
private final Consumer<StorageSlotKey> storagePreloader; |
|
|
|
|
|
|
|
|
|
|
|
private final AccountConsumingMap<BonsaiValue<BonsaiAccount>> accountsToUpdate; |
|
|
|
private final AccountConsumingMap<DiffBasedValue<ACCOUNT>> accountsToUpdate; |
|
|
|
private final Map<Address, BonsaiValue<Bytes>> codeToUpdate = new ConcurrentHashMap<>(); |
|
|
|
private final Map<Address, DiffBasedValue<Bytes>> codeToUpdate = new ConcurrentHashMap<>(); |
|
|
|
private final Set<Address> storageToClear = Collections.synchronizedSet(new HashSet<>()); |
|
|
|
private final Set<Address> storageToClear = Collections.synchronizedSet(new HashSet<>()); |
|
|
|
private final EvmConfiguration evmConfiguration; |
|
|
|
private final EvmConfiguration evmConfiguration; |
|
|
|
|
|
|
|
|
|
|
|
// storage sub mapped by _hashed_ key. This is because in self_destruct calls we need to
|
|
|
|
// storage sub mapped by _hashed_ key. This is because in self_destruct calls we need to
|
|
|
|
// enumerate the old storage and delete it. Those are trie stored by hashed key by spec and the
|
|
|
|
// enumerate the old storage and delete it. Those are trie stored by hashed key by spec and the
|
|
|
|
// alternative was to keep a giant pre-image cache of the entire trie.
|
|
|
|
// alternative was to keep a giant pre-image cache of the entire trie.
|
|
|
|
private final Map<Address, StorageConsumingMap<StorageSlotKey, BonsaiValue<UInt256>>> |
|
|
|
private final Map<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>> |
|
|
|
storageToUpdate = new ConcurrentHashMap<>(); |
|
|
|
storageToUpdate = new ConcurrentHashMap<>(); |
|
|
|
|
|
|
|
|
|
|
|
private boolean isAccumulatorStateChanged; |
|
|
|
private boolean isAccumulatorStateChanged; |
|
|
|
|
|
|
|
|
|
|
|
public BonsaiWorldStateUpdateAccumulator( |
|
|
|
public DiffBasedWorldStateUpdateAccumulator( |
|
|
|
final BonsaiWorldView world, |
|
|
|
final DiffBasedWorldView world, |
|
|
|
final Consumer<BonsaiValue<BonsaiAccount>> accountPreloader, |
|
|
|
final Consumer<DiffBasedValue<ACCOUNT>> accountPreloader, |
|
|
|
final Consumer<StorageSlotKey> storagePreloader, |
|
|
|
final Consumer<StorageSlotKey> storagePreloader, |
|
|
|
final EvmConfiguration evmConfiguration) { |
|
|
|
final EvmConfiguration evmConfiguration) { |
|
|
|
super(world, evmConfiguration); |
|
|
|
super(world, evmConfiguration); |
|
|
|
@ -89,15 +93,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
this.evmConfiguration = evmConfiguration; |
|
|
|
this.evmConfiguration = evmConfiguration; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
public BonsaiWorldStateUpdateAccumulator copy() { |
|
|
|
protected void cloneFromUpdater(final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> source) { |
|
|
|
final BonsaiWorldStateUpdateAccumulator copy = |
|
|
|
|
|
|
|
new BonsaiWorldStateUpdateAccumulator( |
|
|
|
|
|
|
|
wrappedWorldView(), accountPreloader, storagePreloader, evmConfiguration); |
|
|
|
|
|
|
|
copy.cloneFromUpdater(this); |
|
|
|
|
|
|
|
return copy; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void cloneFromUpdater(final BonsaiWorldStateUpdateAccumulator source) { |
|
|
|
|
|
|
|
accountsToUpdate.putAll(source.getAccountsToUpdate()); |
|
|
|
accountsToUpdate.putAll(source.getAccountsToUpdate()); |
|
|
|
codeToUpdate.putAll(source.codeToUpdate); |
|
|
|
codeToUpdate.putAll(source.codeToUpdate); |
|
|
|
storageToClear.addAll(source.storageToClear); |
|
|
|
storageToClear.addAll(source.storageToClear); |
|
|
|
@ -107,14 +103,25 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
this.isAccumulatorStateChanged = true; |
|
|
|
this.isAccumulatorStateChanged = true; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected Consumer<DiffBasedValue<ACCOUNT>> getAccountPreloader() { |
|
|
|
|
|
|
|
return accountPreloader; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected Consumer<StorageSlotKey> getStoragePreloader() { |
|
|
|
|
|
|
|
return storagePreloader; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected EvmConfiguration getEvmConfiguration() { |
|
|
|
|
|
|
|
return evmConfiguration; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Account get(final Address address) { |
|
|
|
public Account get(final Address address) { |
|
|
|
return super.get(address); |
|
|
|
return super.get(address); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
protected UpdateTrackingAccount<BonsaiAccount> track( |
|
|
|
protected UpdateTrackingAccount<ACCOUNT> track(final UpdateTrackingAccount<ACCOUNT> account) { |
|
|
|
final UpdateTrackingAccount<BonsaiAccount> account) { |
|
|
|
|
|
|
|
return super.track(account); |
|
|
|
return super.track(account); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -125,10 +132,10 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public MutableAccount createAccount(final Address address, final long nonce, final Wei balance) { |
|
|
|
public MutableAccount createAccount(final Address address, final long nonce, final Wei balance) { |
|
|
|
BonsaiValue<BonsaiAccount> bonsaiValue = accountsToUpdate.get(address); |
|
|
|
DiffBasedValue<ACCOUNT> bonsaiValue = accountsToUpdate.get(address); |
|
|
|
|
|
|
|
|
|
|
|
if (bonsaiValue == null) { |
|
|
|
if (bonsaiValue == null) { |
|
|
|
bonsaiValue = new BonsaiValue<>(null, null); |
|
|
|
bonsaiValue = new DiffBasedValue<>(null, null); |
|
|
|
accountsToUpdate.put(address, bonsaiValue); |
|
|
|
accountsToUpdate.put(address, bonsaiValue); |
|
|
|
} else if (bonsaiValue.getUpdated() != null) { |
|
|
|
} else if (bonsaiValue.getUpdated() != null) { |
|
|
|
if (bonsaiValue.getUpdated().isEmpty()) { |
|
|
|
if (bonsaiValue.getUpdated().isEmpty()) { |
|
|
|
@ -138,8 +145,8 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
final BonsaiAccount newAccount = |
|
|
|
final ACCOUNT newAccount = |
|
|
|
new BonsaiAccount( |
|
|
|
createAccount( |
|
|
|
this, |
|
|
|
this, |
|
|
|
address, |
|
|
|
address, |
|
|
|
hashAndSavePreImage(address), |
|
|
|
hashAndSavePreImage(address), |
|
|
|
@ -153,12 +160,12 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Map<Address, BonsaiValue<BonsaiAccount>> getAccountsToUpdate() { |
|
|
|
public Map<Address, DiffBasedValue<ACCOUNT>> getAccountsToUpdate() { |
|
|
|
return accountsToUpdate; |
|
|
|
return accountsToUpdate; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Map<Address, BonsaiValue<Bytes>> getCodeToUpdate() { |
|
|
|
public Map<Address, DiffBasedValue<Bytes>> getCodeToUpdate() { |
|
|
|
return codeToUpdate; |
|
|
|
return codeToUpdate; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -167,40 +174,41 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Map<Address, StorageConsumingMap<StorageSlotKey, BonsaiValue<UInt256>>> |
|
|
|
public Map<Address, StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>>> |
|
|
|
getStorageToUpdate() { |
|
|
|
getStorageToUpdate() { |
|
|
|
return storageToUpdate; |
|
|
|
return storageToUpdate; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
protected BonsaiAccount getForMutation(final Address address) { |
|
|
|
protected ACCOUNT getForMutation(final Address address) { |
|
|
|
return loadAccount(address, BonsaiValue::getUpdated); |
|
|
|
return loadAccount(address, DiffBasedValue::getUpdated); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
protected BonsaiAccount loadAccount( |
|
|
|
protected ACCOUNT loadAccount( |
|
|
|
final Address address, |
|
|
|
final Address address, final Function<DiffBasedValue<ACCOUNT>, ACCOUNT> accountFunction) { |
|
|
|
final Function<BonsaiValue<BonsaiAccount>, BonsaiAccount> bonsaiAccountFunction) { |
|
|
|
|
|
|
|
try { |
|
|
|
try { |
|
|
|
final BonsaiValue<BonsaiAccount> bonsaiValue = accountsToUpdate.get(address); |
|
|
|
final DiffBasedValue<ACCOUNT> bonsaiValue = accountsToUpdate.get(address); |
|
|
|
if (bonsaiValue == null) { |
|
|
|
if (bonsaiValue == null) { |
|
|
|
final Account account; |
|
|
|
final Account account; |
|
|
|
if (wrappedWorldView() |
|
|
|
if (wrappedWorldView() instanceof DiffBasedWorldStateUpdateAccumulator) { |
|
|
|
instanceof BonsaiWorldStateUpdateAccumulator bonsaiWorldStateUpdateAccumulator) { |
|
|
|
final DiffBasedWorldStateUpdateAccumulator<ACCOUNT> worldStateUpdateAccumulator = |
|
|
|
account = bonsaiWorldStateUpdateAccumulator.loadAccount(address, bonsaiAccountFunction); |
|
|
|
(DiffBasedWorldStateUpdateAccumulator<ACCOUNT>) wrappedWorldView(); |
|
|
|
|
|
|
|
account = worldStateUpdateAccumulator.loadAccount(address, accountFunction); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
account = wrappedWorldView().get(address); |
|
|
|
account = wrappedWorldView().get(address); |
|
|
|
} |
|
|
|
} |
|
|
|
if (account instanceof BonsaiAccount bonsaiAccount) { |
|
|
|
if (account instanceof DiffBasedAccount diffBasedAccount) { |
|
|
|
BonsaiAccount mutableAccount = new BonsaiAccount(bonsaiAccount, this, true); |
|
|
|
ACCOUNT mutableAccount = copyAccount((ACCOUNT) diffBasedAccount, this, true); |
|
|
|
accountsToUpdate.put(address, new BonsaiValue<>(bonsaiAccount, mutableAccount)); |
|
|
|
accountsToUpdate.put( |
|
|
|
|
|
|
|
address, new DiffBasedValue<>((ACCOUNT) diffBasedAccount, mutableAccount)); |
|
|
|
return mutableAccount; |
|
|
|
return mutableAccount; |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
// add the empty read in accountsToUpdate
|
|
|
|
// add the empty read in accountsToUpdate
|
|
|
|
accountsToUpdate.put(address, new BonsaiValue<>(null, null)); |
|
|
|
accountsToUpdate.put(address, new DiffBasedValue<>(null, null)); |
|
|
|
return null; |
|
|
|
return null; |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
return bonsaiAccountFunction.apply(bonsaiValue); |
|
|
|
return accountFunction.apply(bonsaiValue); |
|
|
|
} |
|
|
|
} |
|
|
|
} catch (MerkleTrieException e) { |
|
|
|
} catch (MerkleTrieException e) { |
|
|
|
// need to throw to trigger the heal
|
|
|
|
// need to throw to trigger the heal
|
|
|
|
@ -228,12 +236,12 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
public void commit() { |
|
|
|
public void commit() { |
|
|
|
this.isAccumulatorStateChanged = true; |
|
|
|
this.isAccumulatorStateChanged = true; |
|
|
|
for (final Address deletedAddress : getDeletedAccounts()) { |
|
|
|
for (final Address deletedAddress : getDeletedAccounts()) { |
|
|
|
final BonsaiValue<BonsaiAccount> accountValue = |
|
|
|
final DiffBasedValue<ACCOUNT> accountValue = |
|
|
|
accountsToUpdate.computeIfAbsent( |
|
|
|
accountsToUpdate.computeIfAbsent( |
|
|
|
deletedAddress, |
|
|
|
deletedAddress, |
|
|
|
__ -> loadAccountFromParent(deletedAddress, new BonsaiValue<>(null, null, true))); |
|
|
|
__ -> loadAccountFromParent(deletedAddress, new DiffBasedValue<>(null, null, true))); |
|
|
|
storageToClear.add(deletedAddress); |
|
|
|
storageToClear.add(deletedAddress); |
|
|
|
final BonsaiValue<Bytes> codeValue = codeToUpdate.get(deletedAddress); |
|
|
|
final DiffBasedValue<Bytes> codeValue = codeToUpdate.get(deletedAddress); |
|
|
|
if (codeValue != null) { |
|
|
|
if (codeValue != null) { |
|
|
|
codeValue.setUpdated(null).setCleared(); |
|
|
|
codeValue.setUpdated(null).setCleared(); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
@ -241,26 +249,27 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
.getCode( |
|
|
|
.getCode( |
|
|
|
deletedAddress, |
|
|
|
deletedAddress, |
|
|
|
Optional.ofNullable(accountValue) |
|
|
|
Optional.ofNullable(accountValue) |
|
|
|
.map(BonsaiValue::getPrior) |
|
|
|
.map(DiffBasedValue::getPrior) |
|
|
|
.map(BonsaiAccount::getCodeHash) |
|
|
|
.map(DiffBasedAccount::getCodeHash) |
|
|
|
.orElse(Hash.EMPTY)) |
|
|
|
.orElse(Hash.EMPTY)) |
|
|
|
.ifPresent( |
|
|
|
.ifPresent( |
|
|
|
deletedCode -> |
|
|
|
deletedCode -> |
|
|
|
codeToUpdate.put(deletedAddress, new BonsaiValue<>(deletedCode, null, true))); |
|
|
|
codeToUpdate.put( |
|
|
|
|
|
|
|
deletedAddress, new DiffBasedValue<>(deletedCode, null, true))); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
// mark all updated storage as to be cleared
|
|
|
|
// mark all updated storage as to be cleared
|
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> deletedStorageUpdates = |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> deletedStorageUpdates = |
|
|
|
storageToUpdate.computeIfAbsent( |
|
|
|
storageToUpdate.computeIfAbsent( |
|
|
|
deletedAddress, |
|
|
|
deletedAddress, |
|
|
|
k -> |
|
|
|
k -> |
|
|
|
new StorageConsumingMap<>( |
|
|
|
new StorageConsumingMap<>( |
|
|
|
deletedAddress, new ConcurrentHashMap<>(), storagePreloader)); |
|
|
|
deletedAddress, new ConcurrentHashMap<>(), storagePreloader)); |
|
|
|
final Iterator<Map.Entry<StorageSlotKey, BonsaiValue<UInt256>>> iter = |
|
|
|
final Iterator<Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>>> iter = |
|
|
|
deletedStorageUpdates.entrySet().iterator(); |
|
|
|
deletedStorageUpdates.entrySet().iterator(); |
|
|
|
while (iter.hasNext()) { |
|
|
|
while (iter.hasNext()) { |
|
|
|
final Map.Entry<StorageSlotKey, BonsaiValue<UInt256>> updateEntry = iter.next(); |
|
|
|
final Map.Entry<StorageSlotKey, DiffBasedValue<UInt256>> updateEntry = iter.next(); |
|
|
|
final BonsaiValue<UInt256> updatedSlot = updateEntry.getValue(); |
|
|
|
final DiffBasedValue<UInt256> updatedSlot = updateEntry.getValue(); |
|
|
|
if (updatedSlot.getPrior() == null || updatedSlot.getPrior().isZero()) { |
|
|
|
if (updatedSlot.getPrior() == null || updatedSlot.getPrior().isZero()) { |
|
|
|
iter.remove(); |
|
|
|
iter.remove(); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
@ -268,7 +277,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
final BonsaiAccount originalValue = accountValue.getPrior(); |
|
|
|
final ACCOUNT originalValue = accountValue.getPrior(); |
|
|
|
if (originalValue != null) { |
|
|
|
if (originalValue != null) { |
|
|
|
// Enumerate and delete addresses not updated
|
|
|
|
// Enumerate and delete addresses not updated
|
|
|
|
wrappedWorldView() |
|
|
|
wrappedWorldView() |
|
|
|
@ -279,7 +288,8 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
new StorageSlotKey(Hash.wrap(keyHash), Optional.empty()); |
|
|
|
new StorageSlotKey(Hash.wrap(keyHash), Optional.empty()); |
|
|
|
if (!deletedStorageUpdates.containsKey(storageSlotKey)) { |
|
|
|
if (!deletedStorageUpdates.containsKey(storageSlotKey)) { |
|
|
|
final UInt256 value = UInt256.fromBytes(RLP.decodeOne(entryValue)); |
|
|
|
final UInt256 value = UInt256.fromBytes(RLP.decodeOne(entryValue)); |
|
|
|
deletedStorageUpdates.put(storageSlotKey, new BonsaiValue<>(value, null, true)); |
|
|
|
deletedStorageUpdates.put( |
|
|
|
|
|
|
|
storageSlotKey, new DiffBasedValue<>(value, null, true)); |
|
|
|
} |
|
|
|
} |
|
|
|
}); |
|
|
|
}); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -293,11 +303,11 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
.forEach( |
|
|
|
.forEach( |
|
|
|
tracked -> { |
|
|
|
tracked -> { |
|
|
|
final Address updatedAddress = tracked.getAddress(); |
|
|
|
final Address updatedAddress = tracked.getAddress(); |
|
|
|
final BonsaiAccount updatedAccount; |
|
|
|
final ACCOUNT updatedAccount; |
|
|
|
final BonsaiValue<BonsaiAccount> updatedAccountValue = |
|
|
|
final DiffBasedValue<ACCOUNT> updatedAccountValue = |
|
|
|
accountsToUpdate.get(updatedAddress); |
|
|
|
accountsToUpdate.get(updatedAddress); |
|
|
|
|
|
|
|
|
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> pendingStorageUpdates = |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> pendingStorageUpdates = |
|
|
|
storageToUpdate.computeIfAbsent( |
|
|
|
storageToUpdate.computeIfAbsent( |
|
|
|
updatedAddress, |
|
|
|
updatedAddress, |
|
|
|
k -> |
|
|
|
k -> |
|
|
|
@ -310,12 +320,12 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if (tracked.getWrappedAccount() == null) { |
|
|
|
if (tracked.getWrappedAccount() == null) { |
|
|
|
updatedAccount = new BonsaiAccount(this, tracked); |
|
|
|
updatedAccount = createAccount(this, tracked); |
|
|
|
tracked.setWrappedAccount(updatedAccount); |
|
|
|
tracked.setWrappedAccount(updatedAccount); |
|
|
|
if (updatedAccountValue == null) { |
|
|
|
if (updatedAccountValue == null) { |
|
|
|
accountsToUpdate.put(updatedAddress, new BonsaiValue<>(null, updatedAccount)); |
|
|
|
accountsToUpdate.put(updatedAddress, new DiffBasedValue<>(null, updatedAccount)); |
|
|
|
codeToUpdate.put( |
|
|
|
codeToUpdate.put( |
|
|
|
updatedAddress, new BonsaiValue<>(null, updatedAccount.getCode())); |
|
|
|
updatedAddress, new DiffBasedValue<>(null, updatedAccount.getCode())); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
updatedAccountValue.setUpdated(updatedAccount); |
|
|
|
updatedAccountValue.setUpdated(updatedAccount); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -333,17 +343,17 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if (tracked.codeWasUpdated()) { |
|
|
|
if (tracked.codeWasUpdated()) { |
|
|
|
final BonsaiValue<Bytes> pendingCode = |
|
|
|
final DiffBasedValue<Bytes> pendingCode = |
|
|
|
codeToUpdate.computeIfAbsent( |
|
|
|
codeToUpdate.computeIfAbsent( |
|
|
|
updatedAddress, |
|
|
|
updatedAddress, |
|
|
|
addr -> |
|
|
|
addr -> |
|
|
|
new BonsaiValue<>( |
|
|
|
new DiffBasedValue<>( |
|
|
|
wrappedWorldView() |
|
|
|
wrappedWorldView() |
|
|
|
.getCode( |
|
|
|
.getCode( |
|
|
|
addr, |
|
|
|
addr, |
|
|
|
Optional.ofNullable(updatedAccountValue) |
|
|
|
Optional.ofNullable(updatedAccountValue) |
|
|
|
.map(BonsaiValue::getPrior) |
|
|
|
.map(DiffBasedValue::getPrior) |
|
|
|
.map(BonsaiAccount::getCodeHash) |
|
|
|
.map(DiffBasedAccount::getCodeHash) |
|
|
|
.orElse(Hash.EMPTY)) |
|
|
|
.orElse(Hash.EMPTY)) |
|
|
|
.orElse(null), |
|
|
|
.orElse(null), |
|
|
|
null)); |
|
|
|
null)); |
|
|
|
@ -368,11 +378,11 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
final StorageSlotKey slotKey = |
|
|
|
final StorageSlotKey slotKey = |
|
|
|
new StorageSlotKey(slotHash, Optional.of(keyUInt)); |
|
|
|
new StorageSlotKey(slotHash, Optional.of(keyUInt)); |
|
|
|
final UInt256 value = storageUpdate.getValue(); |
|
|
|
final UInt256 value = storageUpdate.getValue(); |
|
|
|
final BonsaiValue<UInt256> pendingValue = pendingStorageUpdates.get(slotKey); |
|
|
|
final DiffBasedValue<UInt256> pendingValue = pendingStorageUpdates.get(slotKey); |
|
|
|
if (pendingValue == null) { |
|
|
|
if (pendingValue == null) { |
|
|
|
pendingStorageUpdates.put( |
|
|
|
pendingStorageUpdates.put( |
|
|
|
slotKey, |
|
|
|
slotKey, |
|
|
|
new BonsaiValue<>( |
|
|
|
new DiffBasedValue<>( |
|
|
|
updatedAccount.getOriginalStorageValue(keyUInt), value)); |
|
|
|
updatedAccount.getOriginalStorageValue(keyUInt), value)); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
pendingValue.setUpdated(value); |
|
|
|
pendingValue.setUpdated(value); |
|
|
|
@ -393,7 +403,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Optional<Bytes> getCode(final Address address, final Hash codeHash) { |
|
|
|
public Optional<Bytes> getCode(final Address address, final Hash codeHash) { |
|
|
|
final BonsaiValue<Bytes> localCode = codeToUpdate.get(address); |
|
|
|
final DiffBasedValue<Bytes> localCode = codeToUpdate.get(address); |
|
|
|
if (localCode == null) { |
|
|
|
if (localCode == null) { |
|
|
|
final Optional<Bytes> code = wrappedWorldView().getCode(address, codeHash); |
|
|
|
final Optional<Bytes> code = wrappedWorldView().getCode(address, codeHash); |
|
|
|
if (code.isEmpty() && !codeHash.equals(Hash.EMPTY)) { |
|
|
|
if (code.isEmpty() && !codeHash.equals(Hash.EMPTY)) { |
|
|
|
@ -416,10 +426,10 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Optional<UInt256> getStorageValueByStorageSlotKey( |
|
|
|
public Optional<UInt256> getStorageValueByStorageSlotKey( |
|
|
|
final Address address, final StorageSlotKey storageSlotKey) { |
|
|
|
final Address address, final StorageSlotKey storageSlotKey) { |
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> localAccountStorage = |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> localAccountStorage = |
|
|
|
storageToUpdate.get(address); |
|
|
|
storageToUpdate.get(address); |
|
|
|
if (localAccountStorage != null) { |
|
|
|
if (localAccountStorage != null) { |
|
|
|
final BonsaiValue<UInt256> value = localAccountStorage.get(storageSlotKey); |
|
|
|
final DiffBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey); |
|
|
|
if (value != null) { |
|
|
|
if (value != null) { |
|
|
|
return Optional.ofNullable(value.getUpdated()); |
|
|
|
return Optional.ofNullable(value.getUpdated()); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -429,8 +439,8 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
(wrappedWorldView() instanceof BonsaiWorldState bonsaiWorldState) |
|
|
|
(wrappedWorldView() instanceof BonsaiWorldState bonsaiWorldState) |
|
|
|
? bonsaiWorldState.getStorageValueByStorageSlotKey( |
|
|
|
? bonsaiWorldState.getStorageValueByStorageSlotKey( |
|
|
|
() -> |
|
|
|
() -> |
|
|
|
Optional.ofNullable(loadAccount(address, BonsaiValue::getPrior)) |
|
|
|
Optional.ofNullable(loadAccount(address, DiffBasedValue::getPrior)) |
|
|
|
.map(BonsaiAccount::getStorageRoot), |
|
|
|
.map(DiffBasedAccount::getStorageRoot), |
|
|
|
address, |
|
|
|
address, |
|
|
|
storageSlotKey) |
|
|
|
storageSlotKey) |
|
|
|
: wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey); |
|
|
|
: wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey); |
|
|
|
@ -439,7 +449,8 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
address, |
|
|
|
address, |
|
|
|
key -> |
|
|
|
key -> |
|
|
|
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader)) |
|
|
|
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader)) |
|
|
|
.put(storageSlotKey, new BonsaiValue<>(valueUInt.orElse(null), valueUInt.orElse(null))); |
|
|
|
.put( |
|
|
|
|
|
|
|
storageSlotKey, new DiffBasedValue<>(valueUInt.orElse(null), valueUInt.orElse(null))); |
|
|
|
|
|
|
|
|
|
|
|
return valueUInt; |
|
|
|
return valueUInt; |
|
|
|
} catch (MerkleTrieException e) { |
|
|
|
} catch (MerkleTrieException e) { |
|
|
|
@ -454,10 +465,10 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
// TODO maybe log the read into the trie layer?
|
|
|
|
// TODO maybe log the read into the trie layer?
|
|
|
|
StorageSlotKey storageSlotKey = |
|
|
|
StorageSlotKey storageSlotKey = |
|
|
|
new StorageSlotKey(hashAndSavePreImage(storageKey), Optional.of(storageKey)); |
|
|
|
new StorageSlotKey(hashAndSavePreImage(storageKey), Optional.of(storageKey)); |
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> localAccountStorage = |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> localAccountStorage = |
|
|
|
storageToUpdate.get(address); |
|
|
|
storageToUpdate.get(address); |
|
|
|
if (localAccountStorage != null) { |
|
|
|
if (localAccountStorage != null) { |
|
|
|
final BonsaiValue<UInt256> value = localAccountStorage.get(storageSlotKey); |
|
|
|
final DiffBasedValue<UInt256> value = localAccountStorage.get(storageSlotKey); |
|
|
|
if (value != null) { |
|
|
|
if (value != null) { |
|
|
|
if (value.isCleared()) { |
|
|
|
if (value.isCleared()) { |
|
|
|
return UInt256.ZERO; |
|
|
|
return UInt256.ZERO; |
|
|
|
@ -481,7 +492,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public Map<Bytes32, Bytes> getAllAccountStorage(final Address address, final Hash rootHash) { |
|
|
|
public Map<Bytes32, Bytes> getAllAccountStorage(final Address address, final Hash rootHash) { |
|
|
|
final Map<Bytes32, Bytes> results = wrappedWorldView().getAllAccountStorage(address, rootHash); |
|
|
|
final Map<Bytes32, Bytes> results = wrappedWorldView().getAllAccountStorage(address, rootHash); |
|
|
|
final StorageConsumingMap<StorageSlotKey, BonsaiValue<UInt256>> bonsaiValueStorage = |
|
|
|
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> bonsaiValueStorage = |
|
|
|
storageToUpdate.get(address); |
|
|
|
storageToUpdate.get(address); |
|
|
|
if (bonsaiValueStorage != null) { |
|
|
|
if (bonsaiValueStorage != null) { |
|
|
|
// hash the key to match the implied storage interface of hashed slotKey
|
|
|
|
// hash the key to match the implied storage interface of hashed slotKey
|
|
|
|
@ -497,7 +508,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
@Override |
|
|
|
public BonsaiWorldStateKeyValueStorage getWorldStateStorage() { |
|
|
|
public DiffBasedWorldStateKeyValueStorage getWorldStateStorage() { |
|
|
|
return wrappedWorldView().getWorldStateStorage(); |
|
|
|
return wrappedWorldView().getWorldStateStorage(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
@ -549,7 +560,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
// non-change, a cached read.
|
|
|
|
// non-change, a cached read.
|
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
BonsaiValue<BonsaiAccount> accountValue = accountsToUpdate.get(address); |
|
|
|
DiffBasedValue<ACCOUNT> accountValue = accountsToUpdate.get(address); |
|
|
|
if (accountValue == null) { |
|
|
|
if (accountValue == null) { |
|
|
|
accountValue = loadAccountFromParent(address, accountValue); |
|
|
|
accountValue = loadAccountFromParent(address, accountValue); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -557,7 +568,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
if (expectedValue == null && replacementValue != null) { |
|
|
|
if (expectedValue == null && replacementValue != null) { |
|
|
|
accountsToUpdate.put( |
|
|
|
accountsToUpdate.put( |
|
|
|
address, |
|
|
|
address, |
|
|
|
new BonsaiValue<>(null, new BonsaiAccount(this, address, replacementValue, true))); |
|
|
|
new DiffBasedValue<>(null, createAccount(this, address, replacementValue, true))); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
throw new IllegalStateException( |
|
|
|
throw new IllegalStateException( |
|
|
|
String.format( |
|
|
|
String.format( |
|
|
|
@ -571,8 +582,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
"Expected to create account, but the account exists. Address=%s", address)); |
|
|
|
"Expected to create account, but the account exists. Address=%s", address)); |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
BonsaiAccount.assertCloseEnoughForDiffing( |
|
|
|
assertCloseEnoughForDiffing(accountValue.getUpdated(), |
|
|
|
accountValue.getUpdated(), |
|
|
|
|
|
|
|
expectedValue, |
|
|
|
expectedValue, |
|
|
|
"Address=" + address + " Prior Value in Rolling Change"); |
|
|
|
"Address=" + address + " Prior Value in Rolling Change"); |
|
|
|
} |
|
|
|
} |
|
|
|
@ -585,19 +595,18 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
accountValue.setUpdated(null); |
|
|
|
accountValue.setUpdated(null); |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
accountValue.setUpdated( |
|
|
|
accountValue.setUpdated(createAccount(wrappedWorldView(), address, replacementValue, true)); |
|
|
|
new BonsaiAccount(wrappedWorldView(), address, replacementValue, true)); |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
private BonsaiValue<BonsaiAccount> loadAccountFromParent( |
|
|
|
private DiffBasedValue<ACCOUNT> loadAccountFromParent( |
|
|
|
final Address address, final BonsaiValue<BonsaiAccount> defaultValue) { |
|
|
|
final Address address, final DiffBasedValue<ACCOUNT> defaultValue) { |
|
|
|
try { |
|
|
|
try { |
|
|
|
final Account parentAccount = wrappedWorldView().get(address); |
|
|
|
final Account parentAccount = wrappedWorldView().get(address); |
|
|
|
if (parentAccount instanceof BonsaiAccount account) { |
|
|
|
if (parentAccount instanceof DiffBasedAccount account) { |
|
|
|
final BonsaiValue<BonsaiAccount> loadedAccountValue = |
|
|
|
final DiffBasedValue<ACCOUNT> loadedAccountValue = |
|
|
|
new BonsaiValue<>(new BonsaiAccount(account), account); |
|
|
|
new DiffBasedValue<>(copyAccount((ACCOUNT) account), ((ACCOUNT) account)); |
|
|
|
accountsToUpdate.put(address, loadedAccountValue); |
|
|
|
accountsToUpdate.put(address, loadedAccountValue); |
|
|
|
return loadedAccountValue; |
|
|
|
return loadedAccountValue; |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
@ -616,7 +625,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
// non-change, a cached read.
|
|
|
|
// non-change, a cached read.
|
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
BonsaiValue<Bytes> codeValue = codeToUpdate.get(address); |
|
|
|
DiffBasedValue<Bytes> codeValue = codeToUpdate.get(address); |
|
|
|
if (codeValue == null) { |
|
|
|
if (codeValue == null) { |
|
|
|
final Bytes storedCode = |
|
|
|
final Bytes storedCode = |
|
|
|
wrappedWorldView() |
|
|
|
wrappedWorldView() |
|
|
|
@ -624,14 +633,14 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
address, Optional.ofNullable(expectedCode).map(Hash::hash).orElse(Hash.EMPTY)) |
|
|
|
address, Optional.ofNullable(expectedCode).map(Hash::hash).orElse(Hash.EMPTY)) |
|
|
|
.orElse(Bytes.EMPTY); |
|
|
|
.orElse(Bytes.EMPTY); |
|
|
|
if (!storedCode.isEmpty()) { |
|
|
|
if (!storedCode.isEmpty()) { |
|
|
|
codeValue = new BonsaiValue<>(storedCode, storedCode); |
|
|
|
codeValue = new DiffBasedValue<>(storedCode, storedCode); |
|
|
|
codeToUpdate.put(address, codeValue); |
|
|
|
codeToUpdate.put(address, codeValue); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
if (codeValue == null) { |
|
|
|
if (codeValue == null) { |
|
|
|
if ((expectedCode == null || expectedCode.isEmpty()) && replacementCode != null) { |
|
|
|
if ((expectedCode == null || expectedCode.isEmpty()) && replacementCode != null) { |
|
|
|
codeToUpdate.put(address, new BonsaiValue<>(null, replacementCode)); |
|
|
|
codeToUpdate.put(address, new DiffBasedValue<>(null, replacementCode)); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
throw new IllegalStateException( |
|
|
|
throw new IllegalStateException( |
|
|
|
String.format( |
|
|
|
String.format( |
|
|
|
@ -659,10 +668,10 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
private Map<StorageSlotKey, BonsaiValue<UInt256>> maybeCreateStorageMap( |
|
|
|
private Map<StorageSlotKey, DiffBasedValue<UInt256>> maybeCreateStorageMap( |
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> storageMap, final Address address) { |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> storageMap, final Address address) { |
|
|
|
if (storageMap == null) { |
|
|
|
if (storageMap == null) { |
|
|
|
final StorageConsumingMap<StorageSlotKey, BonsaiValue<UInt256>> newMap = |
|
|
|
final StorageConsumingMap<StorageSlotKey, DiffBasedValue<UInt256>> newMap = |
|
|
|
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader); |
|
|
|
new StorageConsumingMap<>(address, new ConcurrentHashMap<>(), storagePreloader); |
|
|
|
storageToUpdate.put(address, newMap); |
|
|
|
storageToUpdate.put(address, newMap); |
|
|
|
return newMap; |
|
|
|
return newMap; |
|
|
|
@ -684,13 +693,13 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
// corner case on deletes, non-change
|
|
|
|
// corner case on deletes, non-change
|
|
|
|
return; |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> storageMap = storageToUpdate.get(address); |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> storageMap = storageToUpdate.get(address); |
|
|
|
BonsaiValue<UInt256> slotValue = storageMap == null ? null : storageMap.get(storageSlotKey); |
|
|
|
DiffBasedValue<UInt256> slotValue = storageMap == null ? null : storageMap.get(storageSlotKey); |
|
|
|
if (slotValue == null) { |
|
|
|
if (slotValue == null) { |
|
|
|
final Optional<UInt256> storageValue = |
|
|
|
final Optional<UInt256> storageValue = |
|
|
|
wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey); |
|
|
|
wrappedWorldView().getStorageValueByStorageSlotKey(address, storageSlotKey); |
|
|
|
if (storageValue.isPresent()) { |
|
|
|
if (storageValue.isPresent()) { |
|
|
|
slotValue = new BonsaiValue<>(storageValue.get(), storageValue.get()); |
|
|
|
slotValue = new DiffBasedValue<>(storageValue.get(), storageValue.get()); |
|
|
|
storageToUpdate |
|
|
|
storageToUpdate |
|
|
|
.computeIfAbsent( |
|
|
|
.computeIfAbsent( |
|
|
|
address, |
|
|
|
address, |
|
|
|
@ -702,7 +711,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
if (slotValue == null) { |
|
|
|
if (slotValue == null) { |
|
|
|
if ((expectedValue == null || expectedValue.isZero()) && replacementValue != null) { |
|
|
|
if ((expectedValue == null || expectedValue.isZero()) && replacementValue != null) { |
|
|
|
maybeCreateStorageMap(storageMap, address) |
|
|
|
maybeCreateStorageMap(storageMap, address) |
|
|
|
.put(storageSlotKey, new BonsaiValue<>(null, replacementValue)); |
|
|
|
.put(storageSlotKey, new DiffBasedValue<>(null, replacementValue)); |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
throw new IllegalStateException( |
|
|
|
throw new IllegalStateException( |
|
|
|
String.format( |
|
|
|
String.format( |
|
|
|
@ -729,7 +738,7 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
existingSlotValue == null ? "null" : existingSlotValue.toShortHexString())); |
|
|
|
existingSlotValue == null ? "null" : existingSlotValue.toShortHexString())); |
|
|
|
} |
|
|
|
} |
|
|
|
if (replacementValue == null && slotValue.getPrior() == null) { |
|
|
|
if (replacementValue == null && slotValue.getPrior() == null) { |
|
|
|
final Map<StorageSlotKey, BonsaiValue<UInt256>> thisStorageUpdate = |
|
|
|
final Map<StorageSlotKey, DiffBasedValue<UInt256>> thisStorageUpdate = |
|
|
|
maybeCreateStorageMap(storageMap, address); |
|
|
|
maybeCreateStorageMap(storageMap, address); |
|
|
|
thisStorageUpdate.remove(storageSlotKey); |
|
|
|
thisStorageUpdate.remove(storageSlotKey); |
|
|
|
if (thisStorageUpdate.isEmpty()) { |
|
|
|
if (thisStorageUpdate.isEmpty()) { |
|
|
|
@ -767,69 +776,37 @@ public class BonsaiWorldStateUpdateAccumulator |
|
|
|
deletedAccounts.clear(); |
|
|
|
deletedAccounts.clear(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
public static class AccountConsumingMap<T> extends ForwardingMap<Address, T> { |
|
|
|
protected Hash hashAndSavePreImage(final Bytes bytes) { |
|
|
|
|
|
|
|
// by default do not save hash preImages
|
|
|
|
private final ConcurrentMap<Address, T> accounts; |
|
|
|
return Hash.hash(bytes); |
|
|
|
private final Consumer<T> consumer; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public AccountConsumingMap( |
|
|
|
|
|
|
|
final ConcurrentMap<Address, T> accounts, final Consumer<T> consumer) { |
|
|
|
|
|
|
|
this.accounts = accounts; |
|
|
|
|
|
|
|
this.consumer = consumer; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
|
|
|
|
public T put(@NotNull final Address address, @NotNull final T value) { |
|
|
|
|
|
|
|
consumer.process(address, value); |
|
|
|
|
|
|
|
return accounts.put(address, value); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public Consumer<T> getConsumer() { |
|
|
|
|
|
|
|
return consumer; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
|
|
|
|
protected Map<Address, T> delegate() { |
|
|
|
|
|
|
|
return accounts; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
public static class StorageConsumingMap<K, T> extends ForwardingMap<K, T> { |
|
|
|
public abstract DiffBasedWorldStateUpdateAccumulator<ACCOUNT> copy(); |
|
|
|
|
|
|
|
|
|
|
|
private final Address address; |
|
|
|
protected abstract ACCOUNT copyAccount(final ACCOUNT account); |
|
|
|
|
|
|
|
|
|
|
|
private final ConcurrentMap<K, T> storages; |
|
|
|
protected abstract ACCOUNT copyAccount( |
|
|
|
private final Consumer<K> consumer; |
|
|
|
final ACCOUNT toCopy, final DiffBasedWorldView context, final boolean mutable); |
|
|
|
|
|
|
|
|
|
|
|
public StorageConsumingMap( |
|
|
|
protected abstract ACCOUNT createAccount( |
|
|
|
final Address address, final ConcurrentMap<K, T> storages, final Consumer<K> consumer) { |
|
|
|
final DiffBasedWorldView context, |
|
|
|
this.address = address; |
|
|
|
final Address address, |
|
|
|
this.storages = storages; |
|
|
|
final AccountValue stateTrieAccount, |
|
|
|
this.consumer = consumer; |
|
|
|
final boolean mutable); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
|
|
|
|
public T put(@NotNull final K slotKey, @NotNull final T value) { |
|
|
|
|
|
|
|
consumer.process(address, slotKey); |
|
|
|
|
|
|
|
return storages.put(slotKey, value); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public Consumer<K> getConsumer() { |
|
|
|
protected abstract ACCOUNT createAccount( |
|
|
|
return consumer; |
|
|
|
final DiffBasedWorldView context, |
|
|
|
} |
|
|
|
final Address address, |
|
|
|
|
|
|
|
final Hash addressHash, |
|
|
|
|
|
|
|
final long nonce, |
|
|
|
|
|
|
|
final Wei balance, |
|
|
|
|
|
|
|
final Hash storageRoot, |
|
|
|
|
|
|
|
final Hash codeHash, |
|
|
|
|
|
|
|
final boolean mutable); |
|
|
|
|
|
|
|
|
|
|
|
@Override |
|
|
|
protected abstract ACCOUNT createAccount( |
|
|
|
protected Map<K, T> delegate() { |
|
|
|
final DiffBasedWorldView context, final UpdateTrackingAccount<ACCOUNT> tracked); |
|
|
|
return storages; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public interface Consumer<T> { |
|
|
|
|
|
|
|
void process(final Address address, T value); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
protected Hash hashAndSavePreImage(final Bytes bytes) { |
|
|
|
protected abstract void assertCloseEnoughForDiffing(final ACCOUNT source, final AccountValue account, final String context); |
|
|
|
// by default do not save hash preImages
|
|
|
|
|
|
|
|
return Hash.hash(bytes); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
} |
Karim Taam
11 months ago