From 677f9231259b6187d5fecdb17fcf1e2f670f4a60 Mon Sep 17 00:00:00 2001
From: Daniel Liu <139250065@qq.com>
Date: Tue, 24 Feb 2026 12:57:31 +0800
Subject: [PATCH] refactor(all): track state changes in state db #27349 (#1947)
---
XDCx/tradingstate/XDCx_trie.go | 2 +-
XDCxlending/lendingstate/XDCx_trie.go | 2 +-
core/state/dump.go | 2 +-
core/state/journal.go | 26 ++
core/state/metrics.go | 7 +
core/state/state_object.go | 108 +++++---
core/state/state_test.go | 16 +-
core/state/statedb.go | 346 ++++++++++++++++++++----
core/state/statedb_fuzz_test.go | 374 ++++++++++++++++++++++++++
core/state/statedb_test.go | 2 +-
core/types/state_account.go | 87 ++++++
trie/database.go | 9 +-
trie/iterator_test.go | 18 +-
trie/secure_trie_test.go | 2 +-
trie/sync_test.go | 6 +-
trie/tracer_test.go | 18 +-
trie/trie.go | 5 +-
trie/trie_test.go | 20 +-
trie/trienode/node.go | 24 +-
trie/triestate/state.go | 28 ++
20 files changed, 965 insertions(+), 137 deletions(-)
create mode 100644 core/state/statedb_fuzz_test.go
create mode 100644 trie/triestate/state.go
diff --git a/XDCx/tradingstate/XDCx_trie.go b/XDCx/tradingstate/XDCx_trie.go
index 26773016bd..5a8c8786be 100644
--- a/XDCx/tradingstate/XDCx_trie.go
+++ b/XDCx/tradingstate/XDCx_trie.go
@@ -170,7 +170,7 @@ func (t *XDCXTrie) Commit(onleaf trie.LeafCallback) (common.Hash, error) {
return common.Hash{}, err
}
if nodes != nil {
- if err := t.trie.UpdateDb(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := t.trie.UpdateDb(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
return common.Hash{}, err
}
}
diff --git a/XDCxlending/lendingstate/XDCx_trie.go b/XDCxlending/lendingstate/XDCx_trie.go
index 3d5200e695..0db46a55eb 100644
--- a/XDCxlending/lendingstate/XDCx_trie.go
+++ b/XDCxlending/lendingstate/XDCx_trie.go
@@ -166,7 +166,7 @@ func (t *XDCXTrie) Commit(onleaf trie.LeafCallback) (common.Hash, error) {
return common.Hash{}, err
}
if nodes != nil {
- if err := t.trie.UpdateDb(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := t.trie.UpdateDb(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
return common.Hash{}, err
}
}
diff --git a/core/state/dump.go b/core/state/dump.go
index 401058be21..c1511d0a34 100644
--- a/core/state/dump.go
+++ b/core/state/dump.go
@@ -170,7 +170,7 @@ func (s *StateDB) DumpToCollector(c DumpCollector, conf *DumpConfig) (nextKey []
} else {
address = &addr
}
- obj := newObject(s, addr, data)
+ obj := newObject(s, addr, &data)
if !conf.SkipCode {
account.Code = obj.Code()
}
diff --git a/core/state/journal.go b/core/state/journal.go
index 400c3fdd5f..87edf237ea 100644
--- a/core/state/journal.go
+++ b/core/state/journal.go
@@ -111,6 +111,12 @@ type (
account common.Address
prev *stateObject
prevdestruct bool
+ prevAccount []byte
+ prevStorage map[common.Hash][]byte
+
+ prevAccountOriginExist bool
+ prevAccountOrigin []byte
+ prevStorageOrigin map[common.Hash][]byte
}
selfDestructChange struct {
account common.Address
@@ -186,6 +192,26 @@ func (ch resetObjectChange) revert(s *StateDB) {
if !ch.prevdestruct {
delete(s.stateObjectsDestruct, ch.prev.address)
}
+ if ch.prevAccount != nil {
+ s.accounts[ch.prev.addrHash] = ch.prevAccount
+ } else {
+ delete(s.accounts, ch.prev.addrHash)
+ }
+ if ch.prevStorage != nil {
+ s.storages[ch.prev.addrHash] = ch.prevStorage
+ } else {
+ delete(s.storages, ch.prev.addrHash)
+ }
+ if ch.prevAccountOriginExist {
+ s.accountsOrigin[ch.prev.addrHash] = ch.prevAccountOrigin
+ } else {
+ delete(s.accountsOrigin, ch.prev.addrHash)
+ }
+ if ch.prevStorageOrigin != nil {
+ s.storagesOrigin[ch.prev.addrHash] = ch.prevStorageOrigin
+ } else {
+ delete(s.storagesOrigin, ch.prev.addrHash)
+ }
}
func (ch resetObjectChange) dirtied() *common.Address {
diff --git a/core/state/metrics.go b/core/state/metrics.go
index 800f37d614..4188a033bd 100644
--- a/core/state/metrics.go
+++ b/core/state/metrics.go
@@ -27,4 +27,11 @@ var (
storageTriesUpdatedMeter = metrics.NewRegisteredMeter("state/update/storagenodes", nil)
accountTrieDeletedMeter = metrics.NewRegisteredMeter("state/delete/accountnodes", nil)
storageTriesDeletedMeter = metrics.NewRegisteredMeter("state/delete/storagenodes", nil)
+
+ slotDeletionMaxCount = metrics.NewRegisteredGauge("state/delete/storage/max/slot", nil)
+ slotDeletionMaxSize = metrics.NewRegisteredGauge("state/delete/storage/max/size", nil)
+ slotDeletionTimer = metrics.NewRegisteredResettingTimer("state/delete/storage/timer", nil)
+ slotDeletionCount = metrics.NewRegisteredMeter("state/delete/storage/slot", nil)
+ slotDeletionSize = metrics.NewRegisteredMeter("state/delete/storage/size", nil)
+ slotDeletionSkip = metrics.NewRegisteredGauge("state/delete/storage/skip", nil)
)
diff --git a/core/state/state_object.go b/core/state/state_object.go
index c667334d1c..67e0e97466 100644
--- a/core/state/state_object.go
+++ b/core/state/state_object.go
@@ -55,22 +55,23 @@ func (s Storage) Copy() Storage {
// stateObject represents an Ethereum account which is being modified.
//
// The usage pattern is as follows:
-// First you need to obtain a state object.
-// Account values can be accessed and modified through the object.
-// Finally, call commitTrie to write the modified storage trie into a database.
+// - First you need to obtain a state object.
+// - Account values as well as storages can be accessed and modified through the object.
+// - Finally, call commit to return the changes of storage trie and update account data.
type stateObject struct {
db *StateDB
- address common.Address // address of ethereum account
- addrHash common.Hash // hash of ethereum address of the account
- data types.StateAccount // Account data with all mutations applied in the scope of block
+ address common.Address // address of ethereum account
+ addrHash common.Hash // hash of ethereum address of the account
+ origin *types.StateAccount // Account original data without any change applied, nil means it was not existent
+ data types.StateAccount // Account data with all mutations applied in the scope of block
// Write caches.
trie Trie // storage trie, which becomes non-nil on first access
code Code // contract bytecode, which gets set when code is loaded
- originStorage Storage // Storage cache of original entries to dedup rewrites, reset for every transaction
+ originStorage Storage // Storage cache of original entries to dedup rewrites
pendingStorage Storage // Storage entries that need to be flushed to disk, at the end of an entire block
- dirtyStorage Storage // Storage entries that need to be flushed to disk
+ dirtyStorage Storage // Storage entries that have been modified in the current transaction execution, reset for every transaction
// Cache flags.
dirtyCode bool // true if the code was updated
@@ -94,21 +95,17 @@ func (s *stateObject) empty() bool {
}
// newObject creates a state object.
-func newObject(db *StateDB, address common.Address, data types.StateAccount) *stateObject {
- if data.Balance == nil {
- data.Balance = new(big.Int)
- }
- if data.CodeHash == nil {
- data.CodeHash = types.EmptyCodeHash.Bytes()
- }
- if data.Root == (common.Hash{}) {
- data.Root = types.EmptyRootHash
+func newObject(db *StateDB, address common.Address, acct *types.StateAccount) *stateObject {
+ origin := acct
+ if acct == nil {
+ acct = types.NewEmptyStateAccount()
}
return &stateObject{
db: db,
address: address,
addrHash: crypto.Keccak256Hash(address[:]),
- data: data,
+ origin: origin,
+ data: *acct,
originStorage: make(Storage),
pendingStorage: make(Storage),
dirtyStorage: make(Storage),
@@ -241,6 +238,12 @@ func (s *stateObject) updateTrie() (Trie, error) {
}
// Track the amount of time wasted on updating the storage trie
defer func(start time.Time) { s.db.StorageUpdates += time.Since(start) }(time.Now())
+ // The snapshot storage map for the object
+ var (
+ storage map[common.Hash][]byte
+ origin map[common.Hash][]byte
+ hasher = s.db.hasher
+ )
tr, err := s.getTrie()
if err != nil {
s.db.setError(err)
@@ -252,8 +255,11 @@ func (s *stateObject) updateTrie() (Trie, error) {
if value == s.originStorage[key] {
continue
}
+ prev := s.originStorage[key]
s.originStorage[key] = value
+ // rlp-encoded value to be used by the snapshot
+ var snapshotVal []byte
if (value == common.Hash{}) {
if err := tr.DeleteStorage(s.address, key[:]); err != nil {
s.db.setError(err)
@@ -263,12 +269,40 @@ func (s *stateObject) updateTrie() (Trie, error) {
} else {
trimmedVal := common.TrimLeftZeroes(value[:])
// Encoding []byte cannot fail, ok to ignore the error.
+ snapshotVal, _ = rlp.EncodeToBytes(trimmedVal)
if err := tr.UpdateStorage(s.address, key[:], trimmedVal); err != nil {
s.db.setError(err)
return nil, err
}
s.db.StorageUpdated += 1
}
+ // Cache the mutated storage slots until commit
+ if storage == nil {
+ if storage = s.db.storages[s.addrHash]; storage == nil {
+ storage = make(map[common.Hash][]byte)
+ s.db.storages[s.addrHash] = storage
+ }
+ }
+ khash := crypto.HashData(hasher, key[:])
+ storage[khash] = snapshotVal // snapshotVal will be nil if it's deleted
+
+ // Cache the original value of mutated storage slots
+ if origin == nil {
+ if origin = s.db.storagesOrigin[s.addrHash]; origin == nil {
+ origin = make(map[common.Hash][]byte)
+ s.db.storagesOrigin[s.addrHash] = origin
+ }
+ }
+ // Track the original value of slot only if it's mutated first time
+ if _, ok := origin[khash]; !ok {
+ if prev == (common.Hash{}) {
+ origin[khash] = nil // nil if it was not present previously
+ } else {
+ // Encoding []byte cannot fail, ok to ignore the error.
+ b, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(prev[:]))
+ origin[khash] = b
+ }
+ }
}
if len(s.pendingStorage) > 0 {
s.pendingStorage = make(Storage)
@@ -292,16 +326,15 @@ func (s *stateObject) updateRoot() {
s.data.Root = tr.Hash()
}
-// commitTrie the storage trie of the object to dwb.
-// This updates the trie root.
-func (s *stateObject) commitTrie() (*trienode.NodeSet, error) {
- // If nothing changed, don't bother with hashing anything
+// commit returns the changes made in storage trie and updates the account data.
+func (s *stateObject) commit() (*trienode.NodeSet, error) {
tr, err := s.updateTrie()
if err != nil {
return nil, err
}
// If nothing changed, don't bother with hashing anything
if tr == nil {
+ s.origin = s.data.Copy()
return nil, nil
}
// Track the amount of time wasted on committing the storage trie
@@ -311,6 +344,9 @@ func (s *stateObject) commitTrie() (*trienode.NodeSet, error) {
return nil, err
}
s.data.Root = root
+
+ // Update original account data after commit
+ s.origin = s.data.Copy()
return nodes, nil
}
@@ -345,18 +381,24 @@ func (s *stateObject) setBalance(amount *big.Int) {
}
func (s *stateObject) deepCopy(db *StateDB) *stateObject {
- stateObject := newObject(db, s.address, s.data)
- if s.trie != nil {
- stateObject.trie = db.db.CopyTrie(s.trie)
+ obj := &stateObject{
+ db: db,
+ address: s.address,
+ addrHash: s.addrHash,
+ origin: s.origin,
+ data: s.data,
}
- stateObject.code = s.code
- stateObject.dirtyStorage = s.dirtyStorage.Copy()
- stateObject.originStorage = s.originStorage.Copy()
- stateObject.pendingStorage = s.pendingStorage.Copy()
- stateObject.selfDestructed = s.selfDestructed
- stateObject.dirtyCode = s.dirtyCode
- stateObject.deleted = s.deleted
- return stateObject
+ if s.trie != nil {
+ obj.trie = db.db.CopyTrie(s.trie)
+ }
+ obj.code = s.code
+ obj.dirtyStorage = s.dirtyStorage.Copy()
+ obj.originStorage = s.originStorage.Copy()
+ obj.pendingStorage = s.pendingStorage.Copy()
+ obj.selfDestructed = s.selfDestructed
+ obj.dirtyCode = s.dirtyCode
+ obj.deleted = s.deleted
+ return obj
}
//
diff --git a/core/state/state_test.go b/core/state/state_test.go
index 84264305d0..2a63b6732e 100644
--- a/core/state/state_test.go
+++ b/core/state/state_test.go
@@ -30,22 +30,22 @@ import (
"github.com/XinFinOrg/XDPoSChain/trie"
)
-type stateTest struct {
+type stateEnv struct {
db ethdb.Database
state *StateDB
}
-func newStateTest() *stateTest {
+func newStateEnv() *stateEnv {
db := rawdb.NewMemoryDatabase()
sdb, _ := New(types.EmptyRootHash, NewDatabase(db))
- return &stateTest{db: db, state: sdb}
+ return &stateEnv{db: db, state: sdb}
}
func TestDump(t *testing.T) {
db := rawdb.NewMemoryDatabase()
tdb := NewDatabaseWithConfig(db, &trie.Config{Preimages: true})
sdb, _ := New(types.EmptyRootHash, tdb)
- s := &stateTest{db: db, state: sdb}
+ s := &stateEnv{db: db, state: sdb}
// generate a few entries
obj1 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01}))
@@ -99,7 +99,7 @@ func TestIterativeDump(t *testing.T) {
db := rawdb.NewMemoryDatabase()
tdb := NewDatabaseWithConfig(db, &trie.Config{Preimages: true})
sdb, _ := New(types.EmptyRootHash, tdb)
- s := &stateTest{db: db, state: sdb}
+ s := &stateEnv{db: db, state: sdb}
// generate a few entries
obj1 := s.state.GetOrNewStateObject(common.BytesToAddress([]byte{0x01}))
@@ -133,7 +133,7 @@ func TestIterativeDump(t *testing.T) {
}
func TestNull(t *testing.T) {
- s := newStateTest()
+ s := newStateEnv()
address := common.HexToAddress("0x823140710bf13990e4500136726d8b55")
s.state.CreateAccount(address)
//value := common.FromHex("0x823140710bf13990e4500136726d8b55")
@@ -155,7 +155,7 @@ func TestSnapshot(t *testing.T) {
var storageaddr common.Hash
data1 := common.BytesToHash([]byte{42})
data2 := common.BytesToHash([]byte{43})
- s := newStateTest()
+ s := newStateEnv()
// snapshot the genesis state
genesis := s.state.Snapshot()
@@ -186,7 +186,7 @@ func TestSnapshot(t *testing.T) {
}
func TestSnapshotEmpty(t *testing.T) {
- s := newStateTest()
+ s := newStateEnv()
s.state.RevertToSnapshot(s.state.Snapshot())
}
diff --git a/core/state/statedb.go b/core/state/statedb.go
index 8543fbdcec..29f81829b2 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -35,6 +35,7 @@ import (
"github.com/XinFinOrg/XDPoSChain/rlp"
"github.com/XinFinOrg/XDPoSChain/trie"
"github.com/XinFinOrg/XDPoSChain/trie/trienode"
+ "github.com/XinFinOrg/XDPoSChain/trie/triestate"
)
type revision struct {
@@ -54,18 +55,27 @@ type revision struct {
// must be created with new root and updated database for accessing post-
// commit states.
type StateDB struct {
- db Database
- trie Trie
+ db Database
+ trie Trie
+ hasher crypto.KeccakState
// originalRoot is the pre-state root, before any changes were made.
// It will be updated when the Commit is called.
originalRoot common.Hash
- // This map holds 'live' objects, which will get modified while processing a state transition.
+ // These maps hold the state changes (including the corresponding
+ // original value) that occurred in this **block**.
+ accounts map[common.Hash][]byte // The mutated accounts in 'slim RLP' encoding
+ storages map[common.Hash]map[common.Hash][]byte // The mutated slots in prefix-zero trimmed rlp format
+ accountsOrigin map[common.Hash][]byte // The original value of mutated accounts in 'slim RLP' encoding
+ storagesOrigin map[common.Hash]map[common.Hash][]byte // The original value of mutated slots in prefix-zero trimmed rlp format
+
+ // This map holds 'live' objects, which will get modified while processing
+ // a state transition.
stateObjects map[common.Address]*stateObject
- stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie
- stateObjectsDirty map[common.Address]struct{} // State objects modified in the current execution
- stateObjectsDestruct map[common.Address]struct{} // State objects destructed in the block
+ stateObjectsPending map[common.Address]struct{} // State objects finalized but not yet written to the trie
+ stateObjectsDirty map[common.Address]struct{} // State objects modified in the current execution
+ stateObjectsDestruct map[common.Address]*types.StateAccount // State objects destructed in the block along with its previous value
// DB error.
// State objects are used by the consensus core and VM which are
@@ -79,11 +89,13 @@ type StateDB struct {
// The refund counter, also used by state transitioning.
refund uint64
+ // The tx context and all occurred logs in the scope of transaction.
thash common.Hash
txIndex int
logs map[common.Hash][]*types.Log
logSize uint
+ // Preimages occurred seen by VM in the scope of block.
preimages map[common.Hash][]byte
// Per-transaction access list
@@ -129,20 +141,26 @@ func New(root common.Hash, db Database) (*StateDB, error) {
if err != nil {
return nil, err
}
- return &StateDB{
+ sdb := &StateDB{
db: db,
trie: tr,
originalRoot: root,
+ accounts: make(map[common.Hash][]byte),
+ storages: make(map[common.Hash]map[common.Hash][]byte),
+ accountsOrigin: make(map[common.Hash][]byte),
+ storagesOrigin: make(map[common.Hash]map[common.Hash][]byte),
stateObjects: make(map[common.Address]*stateObject),
stateObjectsPending: make(map[common.Address]struct{}),
stateObjectsDirty: make(map[common.Address]struct{}),
- stateObjectsDestruct: make(map[common.Address]struct{}),
+ stateObjectsDestruct: make(map[common.Address]*types.StateAccount),
logs: make(map[common.Hash][]*types.Log),
preimages: make(map[common.Hash][]byte),
journal: newJournal(),
accessList: newAccessList(),
transientStorage: newTransientStorage(),
- }, nil
+ hasher: crypto.NewKeccakState(),
+ }
+ return sdb, nil
}
// setError remembers the first non-nil error it is called with.
@@ -447,12 +465,12 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common
// lookups will not hit the disk, as it is assumed that the disk data belongs
// to a previous incarnation of the object.
//
- // TODO(rjl493456442): This function should only be supported by 'unwritable'
+ // TODO (rjl493456442): This function should only be supported by 'unwritable'
// state, and all mutations made should be discarded afterward.
obj := s.getStateObject(addr)
if obj != nil {
if _, ok := s.stateObjectsDestruct[addr]; !ok {
- s.stateObjectsDestruct[addr] = struct{}{}
+ s.stateObjectsDestruct[addr] = obj.origin
}
}
newObj, _ := s.createObject(addr)
@@ -461,7 +479,7 @@ func (s *StateDB) SetStorage(addr common.Address, storage map[common.Hash]common
}
// Inherit the metadata of original object if it was existent
if obj != nil {
- newObj.SetCode(common.BytesToHash(obj.CodeHash()), obj.code)
+ newObj.SetCode(common.BytesToHash(obj.CodeHash()), []byte(obj.code))
newObj.SetNonce(obj.Nonce())
newObj.SetBalance(obj.Balance())
}
@@ -549,6 +567,22 @@ func (s *StateDB) updateStateObject(obj *stateObject) {
if err := s.trie.UpdateAccount(addr, &obj.data); err != nil {
s.setError(fmt.Errorf("updateStateObject (%x) error: %v", addr[:], err))
}
+ // Cache the data until commit. Note, this update mechanism is not symmetric
+ // to the deletion, because whereas it is enough to track account updates
+ // at commit time, deletions need tracking at transaction boundary level to
+ // ensure we capture state clearing.
+ s.accounts[obj.addrHash] = types.SlimAccountRLP(obj.data)
+
+ // Track the original value of mutated account, nil means it was not present.
+ // Skip if it has been tracked (because updateStateObject may be called
+ // multiple times in a block).
+ if _, ok := s.accountsOrigin[obj.addrHash]; !ok {
+ if obj.origin == nil {
+ s.accountsOrigin[obj.addrHash] = nil
+ } else {
+ s.accountsOrigin[obj.addrHash] = types.SlimAccountRLP(*obj.origin)
+ }
+ }
}
// deleteStateObject removes the given object from the state trie.
@@ -603,7 +637,7 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
return nil
}
// Insert into the live set
- obj := newObject(s, addr, *data)
+ obj := newObject(s, addr, data)
s.setStateObject(obj)
return obj
}
@@ -625,15 +659,36 @@ func (s *StateDB) GetOrNewStateObject(addr common.Address) *stateObject {
// the given address, it is overwritten and returned as the second return value.
func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject) {
prev = s.getDeletedStateObject(addr) // Note, prev might have been deleted, we need that!
- newobj = newObject(s, addr, types.StateAccount{})
+ newobj = newObject(s, addr, nil)
if prev == nil {
s.journal.append(createObjectChange{account: addr})
} else {
+ // The original account should be marked as destructed and all cached
+ // account and storage data should be cleared as well. Note, it must
+ // be done here, otherwise the destruction event of "original account"
+ // will be lost.
_, prevdestruct := s.stateObjectsDestruct[prev.address]
if !prevdestruct {
- s.stateObjectsDestruct[prev.address] = struct{}{}
+ s.stateObjectsDestruct[prev.address] = prev.origin
}
- s.journal.append(resetObjectChange{account: addr, prev: prev, prevdestruct: prevdestruct})
+ // There may be some cached account/storage data already since IntermediateRoot
+ // will be called for each transaction before byzantium fork which will always
+ // cache the latest account/storage data.
+ prevAccount, ok := s.accountsOrigin[prev.addrHash]
+ s.journal.append(resetObjectChange{
+ account: addr,
+ prev: prev,
+ prevdestruct: prevdestruct,
+ prevAccount: s.accounts[prev.addrHash],
+ prevStorage: s.storages[prev.addrHash],
+ prevAccountOriginExist: ok,
+ prevAccountOrigin: prevAccount,
+ prevStorageOrigin: s.storagesOrigin[prev.addrHash],
+ })
+ delete(s.accounts, prev.addrHash)
+ delete(s.storages, prev.addrHash)
+ delete(s.accountsOrigin, prev.addrHash)
+ delete(s.storagesOrigin, prev.addrHash)
}
newobj.created = true
@@ -720,15 +775,20 @@ func (s *StateDB) Copy() *StateDB {
db: s.db,
trie: s.db.CopyTrie(s.trie),
originalRoot: s.originalRoot,
+ accounts: make(map[common.Hash][]byte),
+ storages: make(map[common.Hash]map[common.Hash][]byte),
+ accountsOrigin: make(map[common.Hash][]byte),
+ storagesOrigin: make(map[common.Hash]map[common.Hash][]byte),
stateObjects: make(map[common.Address]*stateObject, len(s.journal.dirties)),
stateObjectsPending: make(map[common.Address]struct{}, len(s.stateObjectsPending)),
stateObjectsDirty: make(map[common.Address]struct{}, len(s.journal.dirties)),
- stateObjectsDestruct: make(map[common.Address]struct{}, len(s.stateObjectsDestruct)),
+ stateObjectsDestruct: make(map[common.Address]*types.StateAccount, len(s.stateObjectsDestruct)),
refund: s.refund,
logs: make(map[common.Hash][]*types.Log, len(s.logs)),
logSize: s.logSize,
preimages: maps.Clone(s.preimages),
journal: newJournal(),
+ hasher: crypto.NewKeccakState(),
}
// Copy the dirty states, logs, and preimages
for addr := range s.journal.dirties {
@@ -762,8 +822,17 @@ func (s *StateDB) Copy() *StateDB {
}
state.stateObjectsDirty[addr] = struct{}{}
}
- // Deep copy the destruction flag.
- state.stateObjectsDestruct = maps.Clone(s.stateObjectsDestruct)
+ // Deep copy the destruction markers.
+ for addr, value := range s.stateObjectsDestruct {
+ state.stateObjectsDestruct[addr] = value
+ }
+ // Deep copy the state changes made in the scope of block
+ // along with their original values.
+ state.accounts = copyAccounts(s.accounts)
+ state.storages = copyStorages(s.storages)
+ state.accountsOrigin = copyAccounts(s.accountsOrigin)
+ state.storagesOrigin = copyStorages(s.storagesOrigin)
+
// Deep copy the logs occurred in the scope of block
for hash, logs := range s.logs {
cpy := make([]*types.Log, len(logs))
@@ -773,7 +842,6 @@ func (s *StateDB) Copy() *StateDB {
}
state.logs[hash] = cpy
}
- state.preimages = maps.Clone(s.preimages)
// Do we need to copy the access list and transient storage?
// In practice: No. At the start of a transaction, these two lists are empty.
// In practice, we only ever copy state _between_ transactions/blocks, never
@@ -827,14 +895,22 @@ func (s *StateDB) Finalise(deleteEmptyObjects bool) {
if obj.selfDestructed || (deleteEmptyObjects && obj.empty()) {
obj.deleted = true
+
// We need to maintain account deletions explicitly (will remain
// set indefinitely). Note only the first occurred self-destruct
// event is tracked.
if _, ok := s.stateObjectsDestruct[obj.address]; !ok {
- s.stateObjectsDestruct[obj.address] = struct{}{}
+ s.stateObjectsDestruct[obj.address] = obj.origin
}
+ // Note, we can't do this only at the end of a block because multiple
+ // transactions within the same block might self destruct and then
+ // resurrect an account; but the snapshotter needs both events.
+ delete(s.accounts, obj.addrHash) // Clear out any previously updated account data (may be recreated via a resurrect)
+ delete(s.storages, obj.addrHash) // Clear out any previously updated storage data (may be recreated via a resurrect)
+ delete(s.accountsOrigin, obj.addrHash) // Clear out any previously updated account data (may be recreated via a resurrect)
+ delete(s.storagesOrigin, obj.addrHash) // Clear out any previously updated storage data (may be recreated via a resurrect)
} else {
- obj.finalise()
+ obj.finalise() // Prefetch slots in the background
}
obj.created = false
s.stateObjectsPending[addr] = struct{}{}
@@ -890,6 +966,135 @@ func (s *StateDB) clearJournalAndRefund() {
s.refund = 0
}
+// deleteStorage iterates the storage trie belongs to the account and mark all
+// slots inside as deleted.
+func (s *StateDB) deleteStorage(addr common.Address, addrHash common.Hash, root common.Hash) (bool, map[common.Hash][]byte, *trienode.NodeSet, error) {
+ start := time.Now()
+ tr, err := s.db.OpenStorageTrie(s.originalRoot, addr, root)
+ if err != nil {
+ return false, nil, nil, fmt.Errorf("failed to open storage trie, err: %w", err)
+ }
+ it, err := tr.NodeIterator(nil)
+ if err != nil {
+ return false, nil, nil, fmt.Errorf("failed to open storage iterator, err: %w", err)
+ }
+ var (
+ set = trienode.NewNodeSet(addrHash)
+ slots = make(map[common.Hash][]byte)
+ stateSize common.StorageSize
+ nodeSize common.StorageSize
+ )
+ for it.Next(true) {
+ // arbitrary stateSize limit, make it configurable
+ if stateSize+nodeSize > 512*1024*1024 {
+ log.Info("Skip large storage deletion", "address", addr.Hex(), "states", stateSize, "nodes", nodeSize)
+ slotDeletionSkip.Inc(1)
+ return true, nil, nil, nil
+ }
+ if it.Leaf() {
+ slots[common.BytesToHash(it.LeafKey())] = common.CopyBytes(it.LeafBlob())
+ stateSize += common.StorageSize(common.HashLength + len(it.LeafBlob()))
+ continue
+ }
+ if it.Hash() == (common.Hash{}) {
+ continue
+ }
+ nodeSize += common.StorageSize(len(it.Path()) + len(it.NodeBlob()))
+ set.AddNode(it.Path(), trienode.NewWithPrev(common.Hash{}, nil, it.NodeBlob()))
+ }
+ if err := it.Error(); err != nil {
+ return false, nil, nil, err
+ }
+
+ if int64(len(slots)) > slotDeletionMaxCount.Snapshot().Value() {
+ slotDeletionMaxCount.Update(int64(len(slots)))
+ }
+ if int64(stateSize+nodeSize) > slotDeletionMaxSize.Snapshot().Value() {
+ slotDeletionMaxSize.Update(int64(stateSize + nodeSize))
+ }
+ slotDeletionTimer.UpdateSince(start)
+ slotDeletionCount.Mark(int64(len(slots)))
+ slotDeletionSize.Mark(int64(stateSize + nodeSize))
+
+ return false, slots, set, nil
+}
+
+// handleDestruction processes all destruction markers and deletes the account
+// and associated storage slots if necessary. There are four possible situations
+// here:
+//
+// - the account was not existent and be marked as destructed
+//
+// - the account was not existent and be marked as destructed,
+// however, it's resurrected later in the same block.
+//
+// - the account was existent and be marked as destructed
+//
+// - the account was existent and be marked as destructed,
+// however it's resurrected later in the same block.
+//
+// In case (a), nothing needs be deleted, nil to nil transition can be ignored.
+//
+// In case (b), nothing needs be deleted, nil is used as the original value for
+// newly created account and storages
+//
+// In case (c), **original** account along with its storages should be deleted,
+// with their values be tracked as original value.
+//
+// In case (d), **original** account along with its storages should be deleted,
+// with their values be tracked as original value.
+func (s *StateDB) handleDestruction(nodes *trienode.MergedNodeSet) (map[common.Hash]struct{}, error) {
+ incomplete := make(map[common.Hash]struct{})
+ for addr, prev := range s.stateObjectsDestruct {
+ // The original account was non-existing, and it's marked as destructed
+ // in the scope of block. It can be case (a) or (b).
+ // - for (a), skip it without doing anything.
+ // - for (b), track account's original value as nil. It may overwrite
+ // the data cached in s.accountsOrigin set by 'updateStateObject'.
+ addrHash := crypto.Keccak256Hash(addr[:])
+ if prev == nil {
+ if _, ok := s.accounts[addrHash]; ok {
+ s.accountsOrigin[addrHash] = nil // case (b)
+ }
+ continue
+ }
+ // It can overwrite the data in s.accountsOrigin set by 'updateStateObject'.
+ s.accountsOrigin[addrHash] = types.SlimAccountRLP(*prev) // case (c) or (d)
+
+ // Short circuit if the storage was empty.
+ if prev.Root == types.EmptyRootHash {
+ continue
+ }
+ // Remove storage slots belong to the account.
+ aborted, slots, set, err := s.deleteStorage(addr, addrHash, prev.Root)
+ if err != nil {
+ return nil, fmt.Errorf("failed to delete storage, err: %w", err)
+ }
+ // The storage is too huge to handle, skip it but mark as incomplete.
+ // For case (d), the account is resurrected might with a few slots
+ // created. In this case, wipe the entire storage state diff because
+ // of aborted deletion.
+ if aborted {
+ incomplete[addrHash] = struct{}{}
+ delete(s.storagesOrigin, addrHash)
+ continue
+ }
+ if s.storagesOrigin[addrHash] == nil {
+ s.storagesOrigin[addrHash] = slots
+ } else {
+ // It can overwrite the data in s.storagesOrigin[addrHash] set by
+ // 'object.updateTrie'.
+ for key, val := range slots {
+ s.storagesOrigin[addrHash][key] = val
+ }
+ }
+ if err := nodes.Merge(set); err != nil {
+ return nil, err
+ }
+ }
+ return incomplete, nil
+}
+
// Commit writes the state to the underlying in-memory trie database.
// Once the state is committed, tries cached in stateDB (including account
// trie, storage tries) will no longer be functional. A new state instance
@@ -914,38 +1119,39 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
nodes = trienode.NewMergedNodeSet()
codeWriter = s.db.DiskDB().NewBatch()
)
+ // Handle all state deletions first
+ incomplete, err := s.handleDestruction(nodes)
+ if err != nil {
+ return common.Hash{}, err
+ }
+ // Handle all state updates afterwards
for addr := range s.stateObjectsDirty {
- if obj := s.stateObjects[addr]; !obj.deleted {
- // Write any contract code associated with the state object
- if obj.code != nil && obj.dirtyCode {
- s.trie.UpdateContractCode(obj.Address(), common.BytesToHash(obj.CodeHash()), obj.code)
- rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)
- obj.dirtyCode = false
- }
- // Write any storage changes in the state object to its storage trie
- set, err := obj.commitTrie()
- if err != nil {
+ obj := s.stateObjects[addr]
+ if obj.deleted {
+ continue
+ }
+ // Write any contract code associated with the state object
+ if obj.code != nil && obj.dirtyCode {
+ rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)
+ s.trie.UpdateContractCode(obj.Address(), common.BytesToHash(obj.CodeHash()), obj.code)
+ obj.dirtyCode = false
+ }
+ // Write any storage changes in the state object to its storage trie
+ set, err := obj.commit()
+ if err != nil {
+ return common.Hash{}, err
+ }
+ // Merge the dirty nodes of storage trie into global set. It is possible
+ // that the account was destructed and then resurrected in the same block.
+ // In this case, the node set is shared by both accounts.
+ if set != nil {
+ if err := nodes.Merge(set); err != nil {
return common.Hash{}, err
}
- // Merge the dirty nodes of storage trie into global set.
- if set != nil {
- if err := nodes.Merge(set); err != nil {
- return common.Hash{}, err
- }
- updates, deleted := set.Size()
- storageTrieNodesUpdated += updates
- storageTrieNodesDeleted += deleted
- }
+ updates, deleted := set.Size()
+ storageTrieNodesUpdated += updates
+ storageTrieNodesDeleted += deleted
}
- // If the contract is destructed, the storage is still left in the
- // database as dangling data. Theoretically it's should be wiped from
- // database as well, but in hash-based-scheme it's extremely hard to
- // determine that if the trie nodes are also referenced by other storage,
- // and in path-based-scheme some technical challenges are still unsolved.
- // Although it won't affect the correctness but please fix it TODO(rjl493456442).
- }
- if len(s.stateObjectsDirty) > 0 {
- s.stateObjectsDirty = make(map[common.Address]struct{})
}
if codeWriter.ValueSize() > 0 {
if err := codeWriter.Write(); err != nil {
@@ -965,9 +1171,9 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
}
accountTrieNodesUpdated, accountTrieNodesDeleted = set.Size()
}
+
// Report the commit metrics
s.AccountCommits += time.Since(start)
-
accountUpdatedMeter.Mark(int64(s.AccountUpdated))
storageUpdatedMeter.Mark(int64(s.StorageUpdated))
accountDeletedMeter.Mark(int64(s.AccountDeleted))
@@ -979,9 +1185,6 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
s.AccountUpdated, s.AccountDeleted = 0, 0
s.StorageUpdated, s.StorageDeleted = 0, 0
- if len(s.stateObjectsDestruct) > 0 {
- s.stateObjectsDestruct = make(map[common.Address]struct{})
- }
if root == (common.Hash{}) {
root = types.EmptyRootHash
}
@@ -991,12 +1194,24 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
}
if root != origin {
start := time.Now()
- if err := s.db.TrieDB().Update(root, origin, block, nodes); err != nil {
+ set := &triestate.Set{
+ Accounts: s.accountsOrigin,
+ Storages: s.storagesOrigin,
+ Incomplete: incomplete,
+ }
+ if err := s.db.TrieDB().Update(root, origin, block, nodes, set); err != nil {
return common.Hash{}, err
}
s.originalRoot = root
s.TrieDBCommits += time.Since(start)
}
+ // Clear all internal flags at the end of commit operation.
+ s.accounts = make(map[common.Hash][]byte)
+ s.storages = make(map[common.Hash]map[common.Hash][]byte)
+ s.accountsOrigin = make(map[common.Hash][]byte)
+ s.storagesOrigin = make(map[common.Hash]map[common.Hash][]byte)
+ s.stateObjectsDirty = make(map[common.Address]struct{})
+ s.stateObjectsDestruct = make(map[common.Address]*types.StateAccount)
return root, nil
}
@@ -1083,3 +1298,24 @@ func (s *StateDB) GetOwner(candidate common.Address) common.Address {
ret := s.GetState(common.MasternodeVotingSMCBinary, common.BigToHash(locCandidateOwner))
return common.HexToAddress(ret.Hex())
}
+
+// copyAccounts returns a deep-copied account set of the provided one.
+func copyAccounts(set map[common.Hash][]byte) map[common.Hash][]byte {
+ copied := make(map[common.Hash][]byte, len(set))
+ for key, val := range set {
+ copied[key] = common.CopyBytes(val)
+ }
+ return copied
+}
+
+// copyStorages returns a deep-copied storage set of the provided one.
+func copyStorages(set map[common.Hash]map[common.Hash][]byte) map[common.Hash]map[common.Hash][]byte {
+ copied := make(map[common.Hash]map[common.Hash][]byte, len(set))
+ for addr, subset := range set {
+ copied[addr] = make(map[common.Hash][]byte, len(subset))
+ for key, val := range subset {
+ copied[addr][key] = common.CopyBytes(val)
+ }
+ }
+ return copied
+}
diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go
new file mode 100644
index 0000000000..af2fb0f9b3
--- /dev/null
+++ b/core/state/statedb_fuzz_test.go
@@ -0,0 +1,374 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+
+package state
+
+import (
+ "bytes"
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "math"
+ "math/big"
+ "math/rand"
+ "reflect"
+ "strings"
+ "testing"
+ "testing/quick"
+
+ "github.com/XinFinOrg/XDPoSChain/common"
+ "github.com/XinFinOrg/XDPoSChain/core/rawdb"
+ "github.com/XinFinOrg/XDPoSChain/core/tracing"
+ "github.com/XinFinOrg/XDPoSChain/core/types"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
+ "github.com/XinFinOrg/XDPoSChain/trie"
+ "github.com/XinFinOrg/XDPoSChain/trie/triestate"
+)
+
+// A stateTest checks that the state changes are correctly captured. Instances
+// of this test with pseudorandom content are created by Generate.
+//
+// The test works as follows:
+//
+// A list of states are created by applying actions. The state changes between
+// each state instance are tracked and be verified.
+type stateTest struct {
+ addrs []common.Address // all account addresses
+ actions [][]testAction // modifications to the state, grouped by block
+ chunk int // The number of actions per chunk
+ err error // failure details are reported through this field
+}
+
+// newStateTestAction creates a random action that changes state.
+func newStateTestAction(addr common.Address, r *rand.Rand, index int) testAction {
+ actions := []testAction{
+ {
+ name: "SetBalance",
+ fn: func(a testAction, s *StateDB) {
+ s.SetBalance(addr, big.NewInt(a.args[0]), tracing.BalanceChangeUnspecified)
+ },
+ args: make([]int64, 1),
+ },
+ {
+ name: "SetNonce",
+ fn: func(a testAction, s *StateDB) {
+ s.SetNonce(addr, uint64(a.args[0]))
+ },
+ args: make([]int64, 1),
+ },
+ {
+ name: "SetState",
+ fn: func(a testAction, s *StateDB) {
+ var key, val common.Hash
+ binary.BigEndian.PutUint16(key[:], uint16(a.args[0]))
+ binary.BigEndian.PutUint16(val[:], uint16(a.args[1]))
+ s.SetState(addr, key, val)
+ },
+ args: make([]int64, 2),
+ },
+ {
+ name: "SetCode",
+ fn: func(a testAction, s *StateDB) {
+ code := make([]byte, 16)
+ binary.BigEndian.PutUint64(code, uint64(a.args[0]))
+ binary.BigEndian.PutUint64(code[8:], uint64(a.args[1]))
+ s.SetCode(addr, code)
+ },
+ args: make([]int64, 2),
+ },
+ {
+ name: "CreateAccount",
+ fn: func(a testAction, s *StateDB) {
+ s.CreateAccount(addr)
+ },
+ },
+ {
+ name: "SelfDestruct",
+ fn: func(a testAction, s *StateDB) {
+ s.SelfDestruct(addr)
+ },
+ },
+ }
+ var nonRandom = index != -1
+ if index == -1 {
+ index = r.Intn(len(actions))
+ }
+ action := actions[index]
+ var names []string
+ if !action.noAddr {
+ names = append(names, addr.Hex())
+ }
+ for i := range action.args {
+ if nonRandom {
+ action.args[i] = rand.Int63n(10000) + 1 // set balance to non-zero
+ } else {
+ action.args[i] = rand.Int63n(10000)
+ }
+ names = append(names, fmt.Sprint(action.args[i]))
+ }
+ action.name += " " + strings.Join(names, ", ")
+ return action
+}
+
+// Generate returns a new snapshot test of the given size. All randomness is
+// derived from r.
+func (*stateTest) Generate(r *rand.Rand, size int) reflect.Value {
+ addrs := make([]common.Address, 5)
+ for i := range addrs {
+ addrs[i][0] = byte(i)
+ }
+ actions := make([][]testAction, rand.Intn(5)+1)
+
+ for i := 0; i < len(actions); i++ {
+ actions[i] = make([]testAction, size)
+ for j := range actions[i] {
+ if j == 0 {
+ // Always include a set balance action to make sure
+ // the state changes are not empty.
+ actions[i][j] = newStateTestAction(common.HexToAddress("0xdeadbeef"), r, 0)
+ continue
+ }
+ actions[i][j] = newStateTestAction(addrs[r.Intn(len(addrs))], r, -1)
+ }
+ }
+ chunk := int(math.Sqrt(float64(size)))
+ if size > 0 && chunk == 0 {
+ chunk = 1
+ }
+ return reflect.ValueOf(&stateTest{
+ addrs: addrs,
+ actions: actions,
+ chunk: chunk,
+ })
+}
+
+func (test *stateTest) String() string {
+ out := new(bytes.Buffer)
+ for i, actions := range test.actions {
+ fmt.Fprintf(out, "---- block %d ----\n", i)
+ for j, action := range actions {
+ if j%test.chunk == 0 {
+ fmt.Fprintf(out, "---- transaction %d ----\n", j/test.chunk)
+ }
+ fmt.Fprintf(out, "%4d: %s\n", j%test.chunk, action.name)
+ }
+ }
+ return out.String()
+}
+
+func (test *stateTest) run() bool {
+ var (
+ roots []common.Hash
+ accountList []map[common.Hash][]byte
+ storageList []map[common.Hash]map[common.Hash][]byte
+ onCommit = func(states *triestate.Set) {
+ accountList = append(accountList, copyAccounts(states.Accounts))
+ storageList = append(storageList, copyStorages(states.Storages))
+ }
+ disk = rawdb.NewMemoryDatabase()
+ tdb = trie.NewDatabaseWithConfig(disk, &trie.Config{OnCommit: onCommit})
+ sdb = NewDatabaseWithNodeDB(disk, tdb)
+ byzantium = rand.Intn(2) == 0
+ )
+ for i, actions := range test.actions {
+ root := types.EmptyRootHash
+ if i != 0 {
+ root = roots[len(roots)-1]
+ }
+ state, err := New(root, sdb)
+ if err != nil {
+ panic(err)
+ }
+ for i, action := range actions {
+ if i%test.chunk == 0 && i != 0 {
+ if byzantium {
+ state.Finalise(true) // call finalise at the transaction boundary
+ } else {
+ state.IntermediateRoot(true) // call intermediateRoot at the transaction boundary
+ }
+ }
+ action.fn(action, state)
+ }
+ if byzantium {
+ state.Finalise(true) // call finalise at the transaction boundary
+ } else {
+ state.IntermediateRoot(true) // call intermediateRoot at the transaction boundary
+ }
+ nroot, err := state.Commit(0, true) // call commit at the block boundary
+ if err != nil {
+ panic(err)
+ }
+ if nroot == root {
+ return true // filter out non-change state transition
+ }
+ roots = append(roots, nroot)
+ }
+ for i := 0; i < len(test.actions); i++ {
+ root := types.EmptyRootHash
+ if i != 0 {
+ root = roots[i-1]
+ }
+ test.err = test.verify(root, roots[i], tdb, accountList[i], storageList[i])
+ if test.err != nil {
+ return false
+ }
+ }
+ return true
+}
+
+// verifyAccountCreation this function is called once the state diff says that
+// specific account was not present. A serial of checks will be performed to
+// ensure the state diff is correct, includes:
+//
+// - the account was indeed not present in trie
+// - the account is present in new trie, nil->nil is regarded as invalid
+// - the slots transition is correct
+func (test *stateTest) verifyAccountCreation(next common.Hash, db *trie.Database, otr, ntr *trie.Trie, addrHash common.Hash, slots map[common.Hash][]byte) error {
+ // Verify account change
+ oBlob, err := otr.Get(addrHash.Bytes())
+ if err != nil {
+ return err
+ }
+ nBlob, err := ntr.Get(addrHash.Bytes())
+ if err != nil {
+ return err
+ }
+ if len(oBlob) != 0 {
+ return fmt.Errorf("unexpected account in old trie, %x", addrHash)
+ }
+ if len(nBlob) == 0 {
+ return fmt.Errorf("missing account in new trie, %x", addrHash)
+ }
+
+ // Verify storage changes
+ var nAcct types.StateAccount
+ if err := rlp.DecodeBytes(nBlob, &nAcct); err != nil {
+ return err
+ }
+ // Account has no slot, empty slot set is expected
+ if nAcct.Root == types.EmptyRootHash {
+ if len(slots) != 0 {
+ return fmt.Errorf("unexpected slot changes %x", addrHash)
+ }
+ return nil
+ }
+ // Account has slots, ensure all new slots are contained
+ st, err := trie.New(trie.StorageTrieID(next, addrHash, nAcct.Root), db)
+ if err != nil {
+ return err
+ }
+ for key, val := range slots {
+ st.Update(key.Bytes(), val)
+ }
+ if st.Hash() != types.EmptyRootHash {
+ return errors.New("invalid slot changes")
+ }
+ return nil
+}
+
+// verifyAccountUpdate this function is called once the state diff says that
+// specific account was present. A serial of checks will be performed to
+// ensure the state diff is correct, includes:
+//
+// - the account was indeed present in trie
+// - the account in old trie matches the provided value
+// - the slots transition is correct
+func (test *stateTest) verifyAccountUpdate(next common.Hash, db *trie.Database, otr, ntr *trie.Trie, addrHash common.Hash, origin []byte, slots map[common.Hash][]byte) error {
+ // Verify account change
+ oBlob, err := otr.Get(addrHash.Bytes())
+ if err != nil {
+ return err
+ }
+ nBlob, err := ntr.Get(addrHash.Bytes())
+ if err != nil {
+ return err
+ }
+ if len(oBlob) == 0 {
+ return fmt.Errorf("missing account in old trie, %x", addrHash)
+ }
+ full, err := types.FullAccountRLP(origin)
+ if err != nil {
+ return err
+ }
+ if !bytes.Equal(full, oBlob) {
+ return fmt.Errorf("account value is not matched, %x", addrHash)
+ }
+
+ // Decode accounts
+ var (
+ oAcct types.StateAccount
+ nAcct types.StateAccount
+ nRoot common.Hash
+ )
+ if err := rlp.DecodeBytes(oBlob, &oAcct); err != nil {
+ return err
+ }
+ if len(nBlob) == 0 {
+ nRoot = types.EmptyRootHash
+ } else {
+ if err := rlp.DecodeBytes(nBlob, &nAcct); err != nil {
+ return err
+ }
+ nRoot = nAcct.Root
+ }
+
+ // Verify storage
+ st, err := trie.New(trie.StorageTrieID(next, addrHash, nRoot), db)
+ if err != nil {
+ return err
+ }
+ for key, val := range slots {
+ st.Update(key.Bytes(), val)
+ }
+ if st.Hash() != oAcct.Root {
+ return errors.New("invalid slot changes")
+ }
+ return nil
+}
+
+func (test *stateTest) verify(root common.Hash, next common.Hash, db *trie.Database, accountsOrigin map[common.Hash][]byte, storagesOrigin map[common.Hash]map[common.Hash][]byte) error {
+ otr, err := trie.New(trie.StateTrieID(root), db)
+ if err != nil {
+ return err
+ }
+ ntr, err := trie.New(trie.StateTrieID(next), db)
+ if err != nil {
+ return err
+ }
+ for addrHash, account := range accountsOrigin {
+ var err error
+ if len(account) == 0 {
+ err = test.verifyAccountCreation(next, db, otr, ntr, addrHash, storagesOrigin[addrHash])
+ } else {
+ err = test.verifyAccountUpdate(next, db, otr, ntr, addrHash, accountsOrigin[addrHash], storagesOrigin[addrHash])
+ }
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func TestStateChanges(t *testing.T) {
+ config := &quick.Config{MaxCount: 1000}
+ err := quick.Check((*stateTest).run, config)
+ if cerr, ok := err.(*quick.CheckError); ok {
+ test := cerr.In[0].(*stateTest)
+ t.Errorf("%v:\n%s", test.err, test)
+ } else if err != nil {
+ t.Error(err)
+ }
+}
diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go
index 1adb89f723..5f3ab62cb7 100644
--- a/core/state/statedb_test.go
+++ b/core/state/statedb_test.go
@@ -499,7 +499,7 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error {
}
func TestTouchDelete(t *testing.T) {
- s := newStateTest()
+ s := newStateEnv()
s.state.GetOrNewStateObject(common.Address{})
root, _ := s.state.Commit(0, false)
s.state.Reset(root)
diff --git a/core/types/state_account.go b/core/types/state_account.go
index b21598e9bd..b10ce0c7b7 100644
--- a/core/types/state_account.go
+++ b/core/types/state_account.go
@@ -17,9 +17,11 @@
package types
import (
+ "bytes"
"math/big"
"github.com/XinFinOrg/XDPoSChain/common"
+ "github.com/XinFinOrg/XDPoSChain/rlp"
)
// StateAccount is the Ethereum consensus representation of accounts.
@@ -30,3 +32,88 @@ type StateAccount struct {
Root common.Hash // merkle root of the storage trie
CodeHash []byte
}
+
+// NewEmptyStateAccount constructs an empty state account.
+func NewEmptyStateAccount() *StateAccount {
+ return &StateAccount{
+ Balance: new(big.Int),
+ Root: EmptyRootHash,
+ CodeHash: EmptyCodeHash.Bytes(),
+ }
+}
+
+// Copy returns a deep-copied state account object.
+func (acct *StateAccount) Copy() *StateAccount {
+ var balance *big.Int
+ if acct.Balance != nil {
+ balance = new(big.Int).Set(acct.Balance)
+ }
+ return &StateAccount{
+ Nonce: acct.Nonce,
+ Balance: balance,
+ Root: acct.Root,
+ CodeHash: common.CopyBytes(acct.CodeHash),
+ }
+}
+
+// SlimAccount is a modified version of an Account, where the root is replaced
+// with a byte slice. This format can be used to represent full-consensus format
+// or slim format which replaces the empty root and code hash as nil byte slice.
+type SlimAccount struct {
+ Nonce uint64
+ Balance *big.Int
+ Root []byte // Nil if root equals to types.EmptyRootHash
+ CodeHash []byte // Nil if hash equals to types.EmptyCodeHash
+}
+
+// SlimAccountRLP encodes the state account in 'slim RLP' format.
+func SlimAccountRLP(account StateAccount) []byte {
+ slim := SlimAccount{
+ Nonce: account.Nonce,
+ Balance: account.Balance,
+ }
+ if account.Root != EmptyRootHash {
+ slim.Root = account.Root[:]
+ }
+ if !bytes.Equal(account.CodeHash, EmptyCodeHash[:]) {
+ slim.CodeHash = account.CodeHash
+ }
+ data, err := rlp.EncodeToBytes(slim)
+ if err != nil {
+ panic(err)
+ }
+ return data
+}
+
+// FullAccount decodes the data on the 'slim RLP' format and returns
+// the consensus format account.
+func FullAccount(data []byte) (*StateAccount, error) {
+ var slim SlimAccount
+ if err := rlp.DecodeBytes(data, &slim); err != nil {
+ return nil, err
+ }
+ var account StateAccount
+ account.Nonce, account.Balance = slim.Nonce, slim.Balance
+
+ // Interpret the storage root and code hash in slim format.
+ if len(slim.Root) == 0 {
+ account.Root = EmptyRootHash
+ } else {
+ account.Root = common.BytesToHash(slim.Root)
+ }
+ if len(slim.CodeHash) == 0 {
+ account.CodeHash = EmptyCodeHash.Bytes()
+ } else {
+ account.CodeHash = slim.CodeHash
+ }
+ return &account, nil
+}
+
+// FullAccountRLP converts data on the 'slim RLP' format into the full RLP-format.
+func FullAccountRLP(data []byte) ([]byte, error) {
+ account, err := FullAccount(data)
+ if err != nil {
+ return nil, err
+ }
+ return rlp.EncodeToBytes(account)
+}
diff --git a/trie/database.go b/trie/database.go
index 9136ca0e56..05396f2ed2 100644
--- a/trie/database.go
+++ b/trie/database.go
@@ -24,12 +24,16 @@ import (
"github.com/XinFinOrg/XDPoSChain/ethdb"
"github.com/XinFinOrg/XDPoSChain/trie/triedb/hashdb"
"github.com/XinFinOrg/XDPoSChain/trie/trienode"
+ "github.com/XinFinOrg/XDPoSChain/trie/triestate"
)
// Config defines all necessary options for database.
type Config struct {
Cache int // Memory allowance (MB) to use for caching trie nodes in memory
Preimages bool // Flag whether the preimage of trie key is recorded
+
+ // Testing hooks
+ OnCommit func(states *triestate.Set) // Hook invoked when commit is performed
}
// backend defines the methods needed to access/update trie nodes in different
@@ -136,7 +140,10 @@ func (db *Database) Reader(blockRoot common.Hash) (Reader, error) {
// given set in order to update state from the specified parent to the specified
// root. The held pre-images accumulated up to this point will be flushed in case
// the size exceeds the threshold.
-func (db *Database) Update(root common.Hash, parent common.Hash, block uint64, nodes *trienode.MergedNodeSet) error {
+func (db *Database) Update(root common.Hash, parent common.Hash, block uint64, nodes *trienode.MergedNodeSet, states *triestate.Set) error {
+ if db.config != nil && db.config.OnCommit != nil {
+ db.config.OnCommit(states)
+ }
if db.preimages != nil {
db.preimages.commit(false)
}
diff --git a/trie/iterator_test.go b/trie/iterator_test.go
index 7e51334686..95adc30f32 100644
--- a/trie/iterator_test.go
+++ b/trie/iterator_test.go
@@ -63,7 +63,7 @@ func TestIterator(t *testing.T) {
trie.MustUpdate([]byte(val.k), []byte(val.v))
}
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
found := make(map[string]string)
@@ -255,7 +255,7 @@ func TestDifferenceIterator(t *testing.T) {
triea.MustUpdate([]byte(val.k), []byte(val.v))
}
rootA, nodesA, _ := triea.Commit(false)
- dba.Update(rootA, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesA))
+ dba.Update(rootA, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
triea, _ = New(TrieID(rootA), dba)
dbb := NewDatabase(rawdb.NewMemoryDatabase())
@@ -264,7 +264,7 @@ func TestDifferenceIterator(t *testing.T) {
trieb.MustUpdate([]byte(val.k), []byte(val.v))
}
rootB, nodesB, _ := trieb.Commit(false)
- dbb.Update(rootB, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesB))
+ dbb.Update(rootB, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
trieb, _ = New(TrieID(rootB), dbb)
found := make(map[string]string)
@@ -297,7 +297,7 @@ func TestUnionIterator(t *testing.T) {
triea.MustUpdate([]byte(val.k), []byte(val.v))
}
rootA, nodesA, _ := triea.Commit(false)
- dba.Update(rootA, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesA))
+ dba.Update(rootA, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesA), nil)
triea, _ = New(TrieID(rootA), dba)
dbb := NewDatabase(rawdb.NewMemoryDatabase())
@@ -306,7 +306,7 @@ func TestUnionIterator(t *testing.T) {
trieb.MustUpdate([]byte(val.k), []byte(val.v))
}
rootB, nodesB, _ := trieb.Commit(false)
- dbb.Update(rootB, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesB))
+ dbb.Update(rootB, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodesB), nil)
trieb, _ = New(TrieID(rootB), dbb)
di, _ := NewUnionIterator([]NodeIterator{triea.MustNodeIterator(nil), trieb.MustNodeIterator(nil)})
@@ -368,7 +368,7 @@ func testIteratorContinueAfterError(t *testing.T, memonly bool, scheme string) {
tr.MustUpdate([]byte(val.k), []byte(val.v))
}
root, nodes, _ := tr.Commit(false)
- tdb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ tdb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
if !memonly {
tdb.Commit(root, false)
}
@@ -484,7 +484,7 @@ func testIteratorContinueAfterSeekError(t *testing.T, memonly bool, scheme strin
break
}
}
- triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
if !memonly {
triedb.Commit(root, false)
}
@@ -601,7 +601,7 @@ func makeLargeTestTrie() (*Database, *StateTrie, *loggingDb) {
trie.MustUpdate(key, val)
}
root, nodes, _ := trie.Commit(false)
- triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
triedb.Commit(root, false)
// Return the generated trie
@@ -644,7 +644,7 @@ func testIteratorNodeBlob(t *testing.T, scheme string) {
trie.MustUpdate([]byte(val.k), []byte(val.v))
}
root, nodes, _ := trie.Commit(false)
- triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
triedb.Commit(root, false)
var found = make(map[common.Hash][]byte)
diff --git a/trie/secure_trie_test.go b/trie/secure_trie_test.go
index 2ee11ccd26..450e3faeef 100644
--- a/trie/secure_trie_test.go
+++ b/trie/secure_trie_test.go
@@ -61,7 +61,7 @@ func makeTestStateTrie() (*Database, *StateTrie, map[string][]byte) {
}
}
root, nodes, _ := trie.Commit(false)
- if err := triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
panic(fmt.Errorf("failed to commit db %v", err))
}
// Re-create the trie based on the new state
diff --git a/trie/sync_test.go b/trie/sync_test.go
index 515d279349..7bf4a6cf7e 100644
--- a/trie/sync_test.go
+++ b/trie/sync_test.go
@@ -57,7 +57,7 @@ func makeTestTrie(scheme string) (ethdb.Database, *Database, *StateTrie, map[str
}
}
root, nodes, _ := trie.Commit(false)
- if err := triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
panic(fmt.Errorf("failed to commit db %v", err))
}
if err := triedb.Commit(root, false); err != nil {
@@ -740,7 +740,7 @@ func testSyncMovingTarget(t *testing.T, scheme string) {
diff[string(key)] = val
}
root, nodes, _ := srcTrie.Commit(false)
- if err := srcDb.Update(root, preRoot, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := srcDb.Update(root, preRoot, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
panic(err)
}
if err := srcDb.Commit(root, false); err != nil {
@@ -765,7 +765,7 @@ func testSyncMovingTarget(t *testing.T, scheme string) {
reverted[k] = val
}
root, nodes, _ = srcTrie.Commit(false)
- if err := srcDb.Update(root, preRoot, 0, trienode.NewWithNodeSet(nodes)); err != nil {
+ if err := srcDb.Update(root, preRoot, 0, trienode.NewWithNodeSet(nodes), nil); err != nil {
panic(err)
}
if err := srcDb.Commit(root, false); err != nil {
diff --git a/trie/tracer_test.go b/trie/tracer_test.go
index 371cee3fa9..90155dab2f 100644
--- a/trie/tracer_test.go
+++ b/trie/tracer_test.go
@@ -71,7 +71,7 @@ func testTrieTracer(t *testing.T, vals []struct{ k, v string }) {
insertSet := copySet(trie.tracer.inserts) // copy before commit
deleteSet := copySet(trie.tracer.deletes) // copy before commit
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
seen := setKeys(iterNodes(db, root))
if !compareSet(insertSet, seen) {
@@ -137,7 +137,7 @@ func testAccessList(t *testing.T, vals []struct{ k, v string }) {
trie.MustUpdate([]byte(val.k), []byte(val.v))
}
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, nodes); err != nil {
@@ -152,7 +152,7 @@ func testAccessList(t *testing.T, vals []struct{ k, v string }) {
trie.MustUpdate([]byte(val.k), randBytes(32))
}
root, nodes, _ = trie.Commit(false)
- db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, nodes); err != nil {
@@ -170,7 +170,7 @@ func testAccessList(t *testing.T, vals []struct{ k, v string }) {
trie.MustUpdate(key, randBytes(32))
}
root, nodes, _ = trie.Commit(false)
- db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, nodes); err != nil {
@@ -185,7 +185,7 @@ func testAccessList(t *testing.T, vals []struct{ k, v string }) {
trie.MustUpdate([]byte(key), nil)
}
root, nodes, _ = trie.Commit(false)
- db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, nodes); err != nil {
@@ -200,7 +200,7 @@ func testAccessList(t *testing.T, vals []struct{ k, v string }) {
trie.MustUpdate([]byte(val.k), nil)
}
root, nodes, _ = trie.Commit(false)
- db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, parent, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, nodes); err != nil {
@@ -219,7 +219,7 @@ func TestAccessListLeak(t *testing.T) {
trie.MustUpdate([]byte(val.k), []byte(val.v))
}
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
var cases = []struct {
op func(tr *Trie)
@@ -269,7 +269,7 @@ func TestTinyTree(t *testing.T) {
trie.MustUpdate([]byte(val.k), randBytes(32))
}
root, set, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(set))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(set), nil)
parent := root
trie, _ = New(TrieID(root), db)
@@ -278,7 +278,7 @@ func TestTinyTree(t *testing.T) {
trie.MustUpdate([]byte(val.k), []byte(val.v))
}
root, set, _ = trie.Commit(false)
- db.Update(root, parent, 0, trienode.NewWithNodeSet(set))
+ db.Update(root, parent, 0, trienode.NewWithNodeSet(set), nil)
trie, _ = New(TrieID(root), db)
if err := verifyAccessList(orig, trie, set); err != nil {
diff --git a/trie/trie.go b/trie/trie.go
index 70e5e494d6..2e9ec69d7c 100644
--- a/trie/trie.go
+++ b/trie/trie.go
@@ -26,6 +26,7 @@ import (
"github.com/XinFinOrg/XDPoSChain/core/types"
"github.com/XinFinOrg/XDPoSChain/log"
"github.com/XinFinOrg/XDPoSChain/trie/trienode"
+ "github.com/XinFinOrg/XDPoSChain/trie/triestate"
)
// Trie is a Merkle Patricia Trie. Use New to create a trie that sits on
@@ -82,11 +83,11 @@ func (t *Trie) InsertPreimage(secKeyCache map[string][]byte) {
}
// NOTE: UpdateDb is only used by XDCx and XDCxlending
-func (t *Trie) UpdateDb(root common.Hash, parent common.Hash, block uint64, nodes *trienode.MergedNodeSet) error {
+func (t *Trie) UpdateDb(root common.Hash, parent common.Hash, block uint64, nodes *trienode.MergedNodeSet, states *triestate.Set) error {
if t.db == nil {
return errors.New("database is nil in trie")
}
- return t.db.Update(root, parent, block, nodes)
+ return t.db.Update(root, parent, block, nodes, states)
}
// Copy returns a copy of Trie.
diff --git a/trie/trie_test.go b/trie/trie_test.go
index 0df376075f..5d9e0dcf8a 100644
--- a/trie/trie_test.go
+++ b/trie/trie_test.go
@@ -90,7 +90,7 @@ func testMissingNode(t *testing.T, memonly bool, scheme string) {
updateString(trie, "120000", "qwerqwerqwerqwerqwerqwerqwerqwer")
updateString(trie, "123456", "asdfasdfasdfasdfasdfasdfasdfasdf")
root, nodes, _ := trie.Commit(false)
- triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
if !memonly {
triedb.Commit(root, false)
@@ -204,7 +204,7 @@ func TestGet(t *testing.T) {
return
}
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
trie, _ = New(TrieID(root), db)
}
}
@@ -276,7 +276,7 @@ func TestReplication(t *testing.T) {
updateString(trie, val.k, val.v)
}
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
// create a new trie on top of the database and check that lookups work.
trie2, err := New(TrieID(root), db)
@@ -295,7 +295,7 @@ func TestReplication(t *testing.T) {
// recreate the trie after commit
if nodes != nil {
- db.Update(hash, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(hash, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
}
trie2, err = New(TrieID(hash), db)
if err != nil {
@@ -522,7 +522,7 @@ func runRandTest(rt randTest) error {
case opCommit:
root, nodes, _ := tr.Commit(true)
if nodes != nil {
- triedb.Update(root, origin, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, origin, 0, trienode.NewWithNodeSet(nodes), nil)
}
newtr, err := New(TrieID(root), triedb)
if err != nil {
@@ -856,7 +856,7 @@ func TestCommitSequence(t *testing.T) {
}
// Flush trie -> database
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
// Flush memdb -> disk (sponge)
db.Commit(root, false)
if got, exp := s.sponge.Sum(nil), tc.expWriteSeqHash; !bytes.Equal(got, exp) {
@@ -897,7 +897,7 @@ func TestCommitSequenceRandomBlobs(t *testing.T) {
}
// Flush trie -> database
root, nodes, _ := trie.Commit(false)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
// Flush memdb -> disk (sponge)
db.Commit(root, false)
if got, exp := s.sponge.Sum(nil), tc.expWriteSeqHash; !bytes.Equal(got, exp) {
@@ -937,7 +937,7 @@ func TestCommitSequenceStackTrie(t *testing.T) {
// Flush trie -> database
root, nodes, _ := trie.Commit(false)
// Flush memdb -> disk (sponge)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
db.Commit(root, false)
// And flush stacktrie -> disk
stRoot, err := stTrie.Commit()
@@ -985,7 +985,7 @@ func TestCommitSequenceSmallRoot(t *testing.T) {
// Flush trie -> database
root, nodes, _ := trie.Commit(false)
// Flush memdb -> disk (sponge)
- db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ db.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
db.Commit(root, false)
// And flush stacktrie -> disk
stRoot, err := stTrie.Commit()
@@ -1156,7 +1156,7 @@ func benchmarkDerefRootFixedSize(b *testing.B, addresses [][20]byte, accounts []
}
h := trie.Hash()
root, nodes, _ := trie.Commit(false)
- triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes))
+ triedb.Update(root, types.EmptyRootHash, 0, trienode.NewWithNodeSet(nodes), nil)
b.StartTimer()
triedb.Dereference(h)
b.StopTimer()
diff --git a/trie/trienode/node.go b/trie/trienode/node.go
index a073a5ce66..fe316a6a92 100644
--- a/trie/trienode/node.go
+++ b/trie/trienode/node.go
@@ -121,6 +121,26 @@ func (set *NodeSet) AddNode(path []byte, n *WithPrev) {
set.Nodes[string(path)] = n
}
+// Merge adds a set of nodes into the set.
+func (set *NodeSet) Merge(owner common.Hash, nodes map[string]*WithPrev) error {
+ if set.Owner != owner {
+ return fmt.Errorf("nodesets belong to different owner are not mergeable %x-%x", set.Owner, owner)
+ }
+ for path, node := range nodes {
+ prev, ok := set.Nodes[path]
+ if ok {
+ // overwrite happens, revoke the counter
+ if prev.IsDeleted() {
+ set.deletes -= 1
+ } else {
+ set.updates -= 1
+ }
+ }
+ set.AddNode([]byte(path), node)
+ }
+ return nil
+}
+
// AddLeaf adds the provided leaf node into set. TODO(rjl493456442) how can
// we get rid of it?
func (set *NodeSet) AddLeaf(parent common.Hash, blob []byte) {
@@ -188,9 +208,9 @@ func NewWithNodeSet(set *NodeSet) *MergedNodeSet {
// Merge merges the provided dirty nodes of a trie into the set. The assumption
// is held that no duplicated set belonging to the same trie will be merged twice.
func (set *MergedNodeSet) Merge(other *NodeSet) error {
- _, present := set.Sets[other.Owner]
+ subset, present := set.Sets[other.Owner]
if present {
- return fmt.Errorf("duplicate trie for owner %#x", other.Owner)
+ return subset.Merge(other.Owner, other.Nodes)
}
set.Sets[other.Owner] = other
return nil
diff --git a/trie/triestate/state.go b/trie/triestate/state.go
new file mode 100644
index 0000000000..264bc43140
--- /dev/null
+++ b/trie/triestate/state.go
@@ -0,0 +1,28 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+
+package triestate
+
+import "github.com/XinFinOrg/XDPoSChain/common"
+
+// Set represents a collection of mutated states during a state transition.
+// The value refers to the original content of state before the transition
+// is made. Nil means that the state was not present previously.
+type Set struct {
+ Accounts map[common.Hash][]byte // Mutated account set, nil means the account was not present
+ Storages map[common.Hash]map[common.Hash][]byte // Mutated storage set, nil means the slot was not present
+ Incomplete map[common.Hash]struct{} // Indicator whether the storage slot is incomplete due to large deletion
+}