From 8f0ad36af6d6e3701985104b713bacdf50a7f609 Mon Sep 17 00:00:00 2001 From: Daniel Liu <139250065@qq.com> Date: Sat, 15 Nov 2025 19:18:52 +0800 Subject: [PATCH] core/state: get rid of field pointer in journal #30361 (#1761) --- core/state/journal.go | 63 +++++++++++++++++++------------------- core/state/state_object.go | 17 +++++----- core/state/statedb.go | 16 +++++----- 3 files changed, 48 insertions(+), 48 deletions(-) diff --git a/core/state/journal.go b/core/state/journal.go index 7b3faba656..6d266a0542 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -20,6 +20,7 @@ import ( "math/big" "github.com/XinFinOrg/XDPoSChain/common" + "github.com/XinFinOrg/XDPoSChain/crypto" ) // journalEntry is a modification entry in the state change journal that can be @@ -87,35 +88,35 @@ func (j *journal) length() int { type ( // Changes to the account trie. createObjectChange struct { - account *common.Address + account common.Address } resetObjectChange struct { - account *common.Address + account common.Address prev *stateObject prevdestruct bool } selfDestructChange struct { - account *common.Address + account common.Address prev bool // whether account had already self-destructed prevbalance *big.Int } // Changes to individual accounts. balanceChange struct { - account *common.Address + account common.Address prev *big.Int } nonceChange struct { - account *common.Address + account common.Address prev uint64 } storageChange struct { - account *common.Address + account common.Address key, prevalue common.Hash } codeChange struct { - account *common.Address - prevcode, prevhash []byte + account common.Address + prevCode []byte } // Changes to other state values. @@ -129,30 +130,30 @@ type ( hash common.Hash } touchChange struct { - account *common.Address + account common.Address } // Changes to the access list accessListAddAccountChange struct { - address *common.Address + address common.Address } accessListAddSlotChange struct { - address *common.Address - slot *common.Hash + address common.Address + slot common.Hash } transientStorageChange struct { - account *common.Address + account common.Address key, prevalue common.Hash } ) func (ch createObjectChange) revert(s *StateDB) { - delete(s.stateObjects, *ch.account) - delete(s.stateObjectsDirty, *ch.account) + delete(s.stateObjects, ch.account) + delete(s.stateObjectsDirty, ch.account) } func (ch createObjectChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch resetObjectChange) revert(s *StateDB) { @@ -163,11 +164,11 @@ func (ch resetObjectChange) revert(s *StateDB) { } func (ch resetObjectChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch selfDestructChange) revert(s *StateDB) { - obj := s.getStateObject(*ch.account) + obj := s.getStateObject(ch.account) if obj != nil { obj.selfDestructed = ch.prev obj.setBalance(ch.prevbalance) @@ -175,7 +176,7 @@ func (ch selfDestructChange) revert(s *StateDB) { } func (ch selfDestructChange) dirtied() *common.Address { - return ch.account + return &ch.account } var ripemd = common.HexToAddress("0000000000000000000000000000000000000003") @@ -184,43 +185,43 @@ func (ch touchChange) revert(s *StateDB) { } func (ch touchChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch balanceChange) revert(s *StateDB) { - s.getStateObject(*ch.account).setBalance(ch.prev) + s.getStateObject(ch.account).setBalance(ch.prev) } func (ch balanceChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch nonceChange) revert(s *StateDB) { - s.getStateObject(*ch.account).setNonce(ch.prev) + s.getStateObject(ch.account).setNonce(ch.prev) } func (ch nonceChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch codeChange) revert(s *StateDB) { - s.getStateObject(*ch.account).setCode(common.BytesToHash(ch.prevhash), ch.prevcode) + s.getStateObject(ch.account).setCode(crypto.Keccak256Hash(ch.prevCode), ch.prevCode) } func (ch codeChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch storageChange) revert(s *StateDB) { - s.getStateObject(*ch.account).setState(ch.key, ch.prevalue) + s.getStateObject(ch.account).setState(ch.key, ch.prevalue) } func (ch storageChange) dirtied() *common.Address { - return ch.account + return &ch.account } func (ch transientStorageChange) revert(s *StateDB) { - s.setTransientState(*ch.account, ch.key, ch.prevalue) + s.setTransientState(ch.account, ch.key, ch.prevalue) } func (ch transientStorageChange) dirtied() *common.Address { @@ -267,7 +268,7 @@ func (ch accessListAddAccountChange) revert(s *StateDB) { (addr) at this point, since no storage adds can remain when come upon a single (addr) change. */ - s.accessList.DeleteAddress(*ch.address) + s.accessList.DeleteAddress(ch.address) } func (ch accessListAddAccountChange) dirtied() *common.Address { @@ -275,7 +276,7 @@ func (ch accessListAddAccountChange) dirtied() *common.Address { } func (ch accessListAddSlotChange) revert(s *StateDB) { - s.accessList.DeleteSlot(*ch.address, *ch.slot) + s.accessList.DeleteSlot(ch.address, ch.slot) } func (ch accessListAddSlotChange) dirtied() *common.Address { diff --git a/core/state/state_object.go b/core/state/state_object.go index a294af1cd7..0c726bc042 100644 --- a/core/state/state_object.go +++ b/core/state/state_object.go @@ -140,7 +140,7 @@ func (s *stateObject) markSelfdestructed() { func (s *stateObject) touch() { s.db.journal.append(touchChange{ - account: &s.address, + account: s.address, }) if s.address == ripemd { // Explicitly put it in the dirty-cache, which is otherwise generated from @@ -226,7 +226,7 @@ func (s *stateObject) SetState(db Database, key, value common.Hash) { } // New value is different, update and journal the change s.db.journal.append(storageChange{ - account: &s.address, + account: s.address, key: key, prevalue: prev, }) @@ -363,7 +363,7 @@ func (s *stateObject) SubBalance(amount *big.Int, reason tracing.BalanceChangeRe func (s *stateObject) SetBalance(amount *big.Int, reason tracing.BalanceChangeReason) { s.db.journal.append(balanceChange{ - account: &s.address, + account: s.address, prev: new(big.Int).Set(s.data.Balance), }) if s.db.logger != nil && s.db.logger.OnBalanceChange != nil { @@ -434,14 +434,13 @@ func (s *stateObject) CodeSize(db Database) int { } func (s *stateObject) SetCode(codeHash common.Hash, code []byte) { - prevcode := s.Code(s.db.db) + prevCode := s.Code(s.db.db) s.db.journal.append(codeChange{ - account: &s.address, - prevhash: s.CodeHash(), - prevcode: prevcode, + account: s.address, + prevCode: prevCode, }) if s.db.logger != nil && s.db.logger.OnCodeChange != nil { - s.db.logger.OnCodeChange(s.address, common.BytesToHash(s.CodeHash()), prevcode, codeHash, code) + s.db.logger.OnCodeChange(s.address, common.BytesToHash(s.CodeHash()), prevCode, codeHash, code) } s.setCode(codeHash, code) } @@ -454,7 +453,7 @@ func (s *stateObject) setCode(codeHash common.Hash, code []byte) { func (s *stateObject) SetNonce(nonce uint64) { s.db.journal.append(nonceChange{ - account: &s.address, + account: s.address, prev: s.data.Nonce, }) if s.db.logger != nil && s.db.logger.OnNonceChange != nil { diff --git a/core/state/statedb.go b/core/state/statedb.go index 809a3a31b7..8ceddf923e 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -463,7 +463,7 @@ func (s *StateDB) SelfDestruct(addr common.Address) { n = new(big.Int) ) s.journal.append(selfDestructChange{ - account: &addr, + account: addr, prev: stateObject.selfDestructed, prevbalance: prev, }) @@ -494,7 +494,7 @@ func (s *StateDB) SetTransientState(addr common.Address, key, value common.Hash) return } s.journal.append(transientStorageChange{ - account: &addr, + account: addr, key: key, prevalue: prev, }) @@ -604,13 +604,13 @@ 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{}) if prev == nil { - s.journal.append(createObjectChange{account: &addr}) + s.journal.append(createObjectChange{account: addr}) } else { _, prevdestruct := s.stateObjectsDestruct[prev.address] if !prevdestruct { s.stateObjectsDestruct[prev.address] = struct{}{} } - s.journal.append(resetObjectChange{account: &addr, prev: prev, prevdestruct: prevdestruct}) + s.journal.append(resetObjectChange{account: addr, prev: prev, prevdestruct: prevdestruct}) } newobj.created = true @@ -999,7 +999,7 @@ func (s *StateDB) Prepare(rules params.Rules, sender, coinbase common.Address, d // AddAddressToAccessList adds the given address to the access list func (s *StateDB) AddAddressToAccessList(addr common.Address) { if s.accessList.AddAddress(addr) { - s.journal.append(accessListAddAccountChange{&addr}) + s.journal.append(accessListAddAccountChange{addr}) } } @@ -1011,12 +1011,12 @@ func (s *StateDB) AddSlotToAccessList(addr common.Address, slot common.Hash) { // scope of 'address' without having the 'address' become already added // to the access list (via call-variant, create, etc). // Better safe than sorry, though - s.journal.append(accessListAddAccountChange{&addr}) + s.journal.append(accessListAddAccountChange{addr}) } if slotMod { s.journal.append(accessListAddSlotChange{ - address: &addr, - slot: &slot, + address: addr, + slot: slot, }) } }