From 239318c841dd7b86b7ddd31199f8ec5514eb3584 Mon Sep 17 00:00:00 2001 From: jsvisa Date: Wed, 28 May 2025 11:57:16 +0800 Subject: [PATCH] core/state: stateUpdate as Public Signed-off-by: jsvisa --- core/state/statedb.go | 22 ++++++------ core/state/statedb_fuzz_test.go | 12 +++---- core/state/stateupdate.go | 64 ++++++++++++++++----------------- 3 files changed, 49 insertions(+), 49 deletions(-) diff --git a/core/state/statedb.go b/core/state/statedb.go index efb09a08a0..b8f3e9d591 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -1133,7 +1133,7 @@ func (s *StateDB) GetTrie() Trie { // commit gathers the state mutations accumulated along with the associated // trie changes, resetting all internal flags with the new state as the base. -func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool) (*stateUpdate, error) { +func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool) (*StateUpdate, error) { // Short circuit in case any database failure occurred earlier. if s.dbErr != nil { return nil, fmt.Errorf("commit aborted due to earlier error: %v", s.dbErr) @@ -1290,15 +1290,15 @@ func (s *StateDB) commit(deleteEmptyObjects bool, noStorageWiping bool) (*stateU // commitAndFlush is a wrapper of commit which also commits the state mutations // to the configured data stores. -func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorageWiping bool) (*stateUpdate, error) { +func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorageWiping bool) (*StateUpdate, error) { ret, err := s.commit(deleteEmptyObjects, noStorageWiping) if err != nil { return nil, err } // Commit dirty contract code if any exists - if db := s.db.TrieDB().Disk(); db != nil && len(ret.codes) > 0 { + if db := s.db.TrieDB().Disk(); db != nil && len(ret.Codes) > 0 { batch := db.NewBatch() - for _, code := range ret.codes { + for _, code := range ret.Codes { rawdb.WriteCode(batch, code.hash, code.blob) } if err := batch.Write(); err != nil { @@ -1307,24 +1307,24 @@ func (s *StateDB) commitAndFlush(block uint64, deleteEmptyObjects bool, noStorag } if !ret.empty() { // If snapshotting is enabled, update the snapshot tree with this new version - if snap := s.db.Snapshot(); snap != nil && snap.Snapshot(ret.originRoot) != nil { + if snap := s.db.Snapshot(); snap != nil && snap.Snapshot(ret.OriginRoot) != nil { start := time.Now() - if err := snap.Update(ret.root, ret.originRoot, ret.accounts, ret.storages); err != nil { - log.Warn("Failed to update snapshot tree", "from", ret.originRoot, "to", ret.root, "err", err) + if err := snap.Update(ret.Root, ret.OriginRoot, ret.Accounts, ret.Storages); err != nil { + log.Warn("Failed to update snapshot tree", "from", ret.OriginRoot, "to", ret.Root, "err", err) } // Keep 128 diff layers in the memory, persistent layer is 129th. // - head layer is paired with HEAD state // - head-1 layer is paired with HEAD-1 state // - head-127 layer(bottom-most diff layer) is paired with HEAD-127 state - if err := snap.Cap(ret.root, TriesInMemory); err != nil { - log.Warn("Failed to cap snapshot tree", "root", ret.root, "layers", TriesInMemory, "err", err) + if err := snap.Cap(ret.Root, TriesInMemory); err != nil { + log.Warn("Failed to cap snapshot tree", "root", ret.Root, "layers", TriesInMemory, "err", err) } s.SnapshotCommits += time.Since(start) } // If trie database is enabled, commit the state update as a new layer if db := s.db.TrieDB(); db != nil { start := time.Now() - if err := db.Update(ret.root, ret.originRoot, block, ret.nodes, ret.stateSet()); err != nil { + if err := db.Update(ret.Root, ret.OriginRoot, block, ret.Nodes, ret.stateSet()); err != nil { return nil, err } s.TrieDBCommits += time.Since(start) @@ -1353,7 +1353,7 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool, noStorageWiping if err != nil { return common.Hash{}, err } - return ret.root, nil + return ret.Root, nil } // Prepare handles the preparatory steps for executing a state transition with. diff --git a/core/state/statedb_fuzz_test.go b/core/state/statedb_fuzz_test.go index 7dada63d45..d5a6366a72 100644 --- a/core/state/statedb_fuzz_test.go +++ b/core/state/statedb_fuzz_test.go @@ -182,11 +182,11 @@ func (test *stateTest) run() bool { accountOrigin []map[common.Address][]byte storages []map[common.Hash]map[common.Hash][]byte storageOrigin []map[common.Address]map[common.Hash][]byte - copyUpdate = func(update *stateUpdate) { - accounts = append(accounts, maps.Clone(update.accounts)) - accountOrigin = append(accountOrigin, maps.Clone(update.accountsOrigin)) - storages = append(storages, maps.Clone(update.storages)) - storageOrigin = append(storageOrigin, maps.Clone(update.storagesOrigin)) + copyUpdate = func(update *StateUpdate) { + accounts = append(accounts, maps.Clone(update.Accounts)) + accountOrigin = append(accountOrigin, maps.Clone(update.AccountsOrigin)) + storages = append(storages, maps.Clone(update.Storages)) + storageOrigin = append(storageOrigin, maps.Clone(update.StoragesOrigin)) } disk = rawdb.NewMemoryDatabase() tdb = triedb.NewDatabase(disk, &triedb.Config{PathDB: pathdb.Defaults}) @@ -236,7 +236,7 @@ func (test *stateTest) run() bool { return true } copyUpdate(ret) - roots = append(roots, ret.root) + roots = append(roots, ret.Root) } for i := 0; i < len(test.actions); i++ { root := types.EmptyRootHash diff --git a/core/state/stateupdate.go b/core/state/stateupdate.go index 75c4ca028c..768568d985 100644 --- a/core/state/stateupdate.go +++ b/core/state/stateupdate.go @@ -60,33 +60,33 @@ type accountUpdate struct { storagesOriginByHash map[common.Hash][]byte } -// stateUpdate represents the difference between two states resulting from state +// StateUpdate represents the difference between two states resulting from state // execution. It contains information about mutated contract codes, accounts, // and storage slots, along with their original values. -type stateUpdate struct { - originRoot common.Hash // hash of the state before applying mutation - root common.Hash // hash of the state after applying mutation - accounts map[common.Hash][]byte // accounts stores mutated accounts in 'slim RLP' encoding - accountsOrigin map[common.Address][]byte // accountsOrigin stores the original values of mutated accounts in 'slim RLP' encoding +type StateUpdate struct { + OriginRoot common.Hash // hash of the state before applying mutation + Root common.Hash // hash of the state after applying mutation + Accounts map[common.Hash][]byte // accounts stores mutated accounts in 'slim RLP' encoding + AccountsOrigin map[common.Address][]byte // accountsOrigin stores the original values of mutated accounts in 'slim RLP' encoding - // storages stores mutated slots in 'prefix-zero-trimmed' RLP format. + // Storages stores mutated slots in 'prefix-zero-trimmed' RLP format. // The value is keyed by account hash and **storage slot key hash**. - storages map[common.Hash]map[common.Hash][]byte + Storages map[common.Hash]map[common.Hash][]byte - // storagesOrigin stores the original values of mutated slots in + // StoragesOrigin stores the original values of mutated slots in // 'prefix-zero-trimmed' RLP format. // (a) the value is keyed by account hash and **storage slot key** if rawStorageKey is true; // (b) the value is keyed by account hash and **storage slot key hash** if rawStorageKey is false; - storagesOrigin map[common.Address]map[common.Hash][]byte - rawStorageKey bool + StoragesOrigin map[common.Address]map[common.Hash][]byte + RawStorageKey bool - codes map[common.Address]contractCode // codes contains the set of dirty codes - nodes *trienode.MergedNodeSet // Aggregated dirty nodes caused by state changes + Codes map[common.Address]contractCode // codes contains the set of dirty codes + Nodes *trienode.MergedNodeSet // Aggregated dirty nodes caused by state changes } // empty returns a flag indicating the state transition is empty or not. -func (sc *stateUpdate) empty() bool { - return sc.originRoot == sc.root +func (sc *StateUpdate) empty() bool { + return sc.OriginRoot == sc.Root } // newStateUpdate constructs a state update object by identifying the differences @@ -95,7 +95,7 @@ func (sc *stateUpdate) empty() bool { // // rawStorageKey is a flag indicating whether to use the raw storage slot key or // the hash of the slot key for constructing state update object. -func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash, deletes map[common.Hash]*accountDelete, updates map[common.Hash]*accountUpdate, nodes *trienode.MergedNodeSet) *stateUpdate { +func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash, deletes map[common.Hash]*accountDelete, updates map[common.Hash]*accountUpdate, nodes *trienode.MergedNodeSet) *StateUpdate { var ( accounts = make(map[common.Hash][]byte) accountsOrigin = make(map[common.Address][]byte) @@ -161,16 +161,16 @@ func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash } } } - return &stateUpdate{ - originRoot: originRoot, - root: root, - accounts: accounts, - accountsOrigin: accountsOrigin, - storages: storages, - storagesOrigin: storagesOrigin, - rawStorageKey: rawStorageKey, - codes: codes, - nodes: nodes, + return &StateUpdate{ + OriginRoot: originRoot, + Root: root, + Accounts: accounts, + AccountsOrigin: accountsOrigin, + Storages: storages, + StoragesOrigin: storagesOrigin, + RawStorageKey: rawStorageKey, + Codes: codes, + Nodes: nodes, } } @@ -178,12 +178,12 @@ func newStateUpdate(rawStorageKey bool, originRoot common.Hash, root common.Hash // object. This function extracts the necessary data from the stateUpdate // struct and formats it into the StateSet structure consumed by the triedb // package. -func (sc *stateUpdate) stateSet() *triedb.StateSet { +func (sc *StateUpdate) stateSet() *triedb.StateSet { return &triedb.StateSet{ - Accounts: sc.accounts, - AccountsOrigin: sc.accountsOrigin, - Storages: sc.storages, - StoragesOrigin: sc.storagesOrigin, - RawStorageKey: sc.rawStorageKey, + Accounts: sc.Accounts, + AccountsOrigin: sc.AccountsOrigin, + Storages: sc.Storages, + StoragesOrigin: sc.StoragesOrigin, + RawStorageKey: sc.RawStorageKey, } }