core/state: remove account reset operation v2 ethereum#29520

Author: gzliudan

core/state/journal.go

@@ -17,6 +17,7 @@
 package state
 
 import (
+	"maps"
 	"math/big"
 
 	"github.com/XinFinOrg/XDPoSChain/common"
@@ -31,6 +32,9 @@ type journalEntry interface {
 
 	// dirtied returns the Ethereum address modified by this journal entry.
 	dirtied() *common.Address
+
+	// copy returns a deep-copied journal entry.
+	copy() journalEntry
 }
 
 // journal contains the list of state modifications applied since the last state
@@ -85,6 +89,18 @@ func (j *journal) length() int {
 	return len(j.entries)
 }
 
+// copy returns a deep-copied journal.
+func (j *journal) copy() *journal {
+	entries := make([]journalEntry, 0, j.length())
+	for i := 0; i < j.length(); i++ {
+		entries = append(entries, j.entries[i].copy())
+	}
+	return &journal{
+		entries: entries,
+		dirties: maps.Clone(j.dirties),
+	}
+}
+
 func (j *journal) createContract(addr common.Address) {
 	j.append(createContractChange{account: addr})
 }
@@ -107,11 +123,6 @@ type (
 	createContractChange struct {
 		account common.Address
 	}
-	resetObjectChange struct {
-		account      common.Address
-		prev         *stateObject
-		prevdestruct bool
-	}
 	selfDestructChange struct {
 		account     common.Address
 		prev        bool // whether account had already self-destructed
@@ -149,6 +160,7 @@ type (
 	touchChange struct {
 		account common.Address
 	}
+
 	// Changes to the access list
 	accessListAddAccountChange struct {
 		address common.Address
@@ -158,6 +170,7 @@ type (
 		slot    common.Hash
 	}
 
+	// Changes to transient storage
 	transientStorageChange struct {
 		account       common.Address
 		key, prevalue common.Hash
@@ -166,32 +179,32 @@ type (
 
 func (ch createObjectChange) revert(s *StateDB) {
 	delete(s.stateObjects, ch.account)
-	delete(s.stateObjectsDirty, ch.account)
 }
 
 func (ch createObjectChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch createObjectChange) copy() journalEntry {
+	return createObjectChange{
+		account: ch.account,
+	}
+}
+
 func (ch createContractChange) revert(s *StateDB) {
-	s.getStateObject(ch.account).created = false
+	s.getStateObject(ch.account).newContract = false
 }
 
 func (ch createContractChange) dirtied() *common.Address {
 	return nil
 }
 
-func (ch resetObjectChange) revert(s *StateDB) {
-	s.setStateObject(ch.prev)
-	if !ch.prevdestruct {
-		delete(s.stateObjectsDestruct, ch.prev.address)
+func (ch createContractChange) copy() journalEntry {
+	return createContractChange{
+		account: ch.account,
 	}
 }
 
-func (ch resetObjectChange) dirtied() *common.Address {
-	return &ch.account
-}
-
 func (ch selfDestructChange) revert(s *StateDB) {
 	obj := s.getStateObject(ch.account)
 	if obj != nil {
@@ -204,6 +217,14 @@ func (ch selfDestructChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch selfDestructChange) copy() journalEntry {
+	return selfDestructChange{
+		account:     ch.account,
+		prev:        ch.prev,
+		prevbalance: new(big.Int).Set(ch.prevbalance),
+	}
+}
+
 var ripemd = common.HexToAddress("0000000000000000000000000000000000000003")
 
 func (ch touchChange) revert(s *StateDB) {
@@ -213,6 +234,12 @@ func (ch touchChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch touchChange) copy() journalEntry {
+	return touchChange{
+		account: ch.account,
+	}
+}
+
 func (ch balanceChange) revert(s *StateDB) {
 	s.getStateObject(ch.account).setBalance(ch.prev)
 }
@@ -221,6 +248,13 @@ func (ch balanceChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch balanceChange) copy() journalEntry {
+	return balanceChange{
+		account: ch.account,
+		prev:    new(big.Int).Set(ch.prev),
+	}
+}
+
 func (ch nonceChange) revert(s *StateDB) {
 	s.getStateObject(ch.account).setNonce(ch.prev)
 }
@@ -229,6 +263,13 @@ func (ch nonceChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch nonceChange) copy() journalEntry {
+	return nonceChange{
+		account: ch.account,
+		prev:    ch.prev,
+	}
+}
+
 func (ch codeChange) revert(s *StateDB) {
 	s.getStateObject(ch.account).setCode(crypto.Keccak256Hash(ch.prevCode), ch.prevCode)
 }
@@ -237,6 +278,13 @@ func (ch codeChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch codeChange) copy() journalEntry {
+	return codeChange{
+		account:  ch.account,
+		prevCode: common.CopyBytes(ch.prevCode),
+	}
+}
+
 func (ch storageChange) revert(s *StateDB) {
 	s.getStateObject(ch.account).setState(ch.key, ch.prevalue)
 }
@@ -245,6 +293,14 @@ func (ch storageChange) dirtied() *common.Address {
 	return &ch.account
 }
 
+func (ch storageChange) copy() journalEntry {
+	return storageChange{
+		account:  ch.account,
+		key:      ch.key,
+		prevalue: ch.prevalue,
+	}
+}
+
 func (ch transientStorageChange) revert(s *StateDB) {
 	s.setTransientState(ch.account, ch.key, ch.prevalue)
 }
@@ -253,6 +309,14 @@ func (ch transientStorageChange) dirtied() *common.Address {
 	return nil
 }
 
+func (ch transientStorageChange) copy() journalEntry {
+	return transientStorageChange{
+		account:  ch.account,
+		key:      ch.key,
+		prevalue: ch.prevalue,
+	}
+}
+
 func (ch refundChange) revert(s *StateDB) {
 	s.refund = ch.prev
 }
@@ -261,6 +325,12 @@ func (ch refundChange) dirtied() *common.Address {
 	return nil
 }
 
+func (ch refundChange) copy() journalEntry {
+	return refundChange{
+		prev: ch.prev,
+	}
+}
+
 func (ch addLogChange) revert(s *StateDB) {
 	logs := s.logs[ch.txhash]
 	if len(logs) == 1 {
@@ -275,6 +345,12 @@ func (ch addLogChange) dirtied() *common.Address {
 	return nil
 }
 
+func (ch addLogChange) copy() journalEntry {
+	return addLogChange{
+		txhash: ch.txhash,
+	}
+}
+
 func (ch addPreimageChange) revert(s *StateDB) {
 	delete(s.preimages, ch.hash)
 }
@@ -283,6 +359,12 @@ func (ch addPreimageChange) dirtied() *common.Address {
 	return nil
 }
 
+func (ch addPreimageChange) copy() journalEntry {
+	return addPreimageChange{
+		hash: ch.hash,
+	}
+}
+
 func (ch accessListAddAccountChange) revert(s *StateDB) {
 	/*
 		One important invariant here, is that whenever a (addr, slot) is added, if the
@@ -300,10 +382,23 @@ func (ch accessListAddAccountChange) dirtied() *common.Address {
 	return nil
 }
 
+func (ch accessListAddAccountChange) copy() journalEntry {
+	return accessListAddAccountChange{
+		address: ch.address,
+	}
+}
+
 func (ch accessListAddSlotChange) revert(s *StateDB) {
 	s.accessList.DeleteSlot(ch.address, ch.slot)
 }
 
 func (ch accessListAddSlotChange) dirtied() *common.Address {
 	return nil
 }
+
+func (ch accessListAddSlotChange) copy() journalEntry {
+	return accessListAddSlotChange{
+		address: ch.address,
+		slot:    ch.slot,
+	}
+}

core/state/state_object.go

@@ -32,22 +32,8 @@ import (
 	"github.com/XinFinOrg/XDPoSChain/trie"
 )
 
-type Code []byte
-
-func (c Code) String() string {
-	return string(c) //strings.Join(Disassemble(c), " ")
-}
-
 type Storage map[common.Hash]common.Hash
 
-func (s Storage) String() (str string) {
-	for key, value := range s {
-		str += fmt.Sprintf("%X : %X\n", key, value)
-	}
-
-	return
-}
-
 func (s Storage) Copy() Storage {
 	return maps.Clone(s)
 }
@@ -60,9 +46,10 @@ func (s Storage) Copy() Storage {
 // Finally, call commitTrie to write the modified storage trie into a database.
 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
 
 	// DB error.
 	// State objects are used by the consensus core and VM which are
@@ -72,8 +59,8 @@ type stateObject struct {
 	dbErr error
 
 	// Write caches.
-	trie Trie // storage trie, which becomes non-nil on first access
-	code Code // contract bytecode, which gets set when code is loaded
+	trie Trie   // storage trie, which becomes non-nil on first access
+	code []byte // contract bytecode, which gets set when code is loaded
 
 	originStorage  Storage // Storage cache of original entries to dedup rewrites, reset for every transaction
 	pendingStorage Storage // Storage entries that need to be flushed to disk, at the end of an entire block
@@ -86,13 +73,12 @@ type stateObject struct {
 	// account is still accessible in the scope of same transaction.
 	selfDestructed bool
 
-	// Flag whether the account was marked as deleted. A self-destructed account
-	// or an account that is considered as empty will be marked as deleted at
-	// the end of transaction and no longer accessible anymore.
-	deleted bool
-
-	// Flag whether the object was created in the current transaction
-	created bool
+	// This is an EIP-6780 flag indicating whether the object is eligible for
+	// self-destruct according to EIP-6780. The flag could be set either when
+	// the contract is just created within the current transaction, or when the
+	// object was previously existent and is being deployed as a contract within
+	// the current transaction.
+	newContract bool
 }
 
 // empty returns whether the account is considered empty.
@@ -248,6 +234,10 @@ func (s *stateObject) finalise() {
 	if len(s.dirtyStorage) > 0 {
 		s.dirtyStorage = make(Storage)
 	}
+	// Revoke the flag at the end of the transaction. It finalizes the status
+	// of the newly-created object as it's no longer eligible for self-destruct
+	// by EIP-6780. For non-newly-created objects, it's a no-op.
+	s.newContract = false
 }
 
 // updateTrie writes cached storage modifications into the object's storage trie.
@@ -371,12 +361,12 @@ func (s *stateObject) deepCopy(db *StateDB) *stateObject {
 		stateObject.trie = db.db.CopyTrie(s.trie)
 	}
 	stateObject.code = s.code
-	stateObject.dirtyStorage = s.dirtyStorage.Copy()
 	stateObject.originStorage = s.originStorage.Copy()
 	stateObject.pendingStorage = s.pendingStorage.Copy()
-	stateObject.selfDestructed = s.selfDestructed
+	stateObject.dirtyStorage = s.dirtyStorage.Copy()
 	stateObject.dirtyCode = s.dirtyCode
-	stateObject.deleted = s.deleted
+	stateObject.selfDestructed = s.selfDestructed
+	stateObject.newContract = s.newContract
 	return stateObject
 }
 
@@ -391,7 +381,7 @@ func (s *stateObject) Address() common.Address {
 
 // Code returns the contract code associated with this object, if any.
 func (s *stateObject) Code(db Database) []byte {
-	if s.code != nil {
+	if len(s.code) != 0 {
 		return s.code
 	}
 	if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {
@@ -409,7 +399,7 @@ func (s *stateObject) Code(db Database) []byte {
 // or zero if none. This method is an almost mirror of Code, but uses a cache
 // inside the database to avoid loading codes seen recently.
 func (s *stateObject) CodeSize(db Database) int {
-	if s.code != nil {
+	if len(s.code) != 0 {
 		return len(s.code)
 	}
 	if bytes.Equal(s.CodeHash(), types.EmptyCodeHash.Bytes()) {