core/state: refactor journalling by implementing journal API

Author: holiman

core/state/journal.go

@@ -83,6 +83,115 @@ func (j *journal) length() int {
 	return len(j.entries)
 }
 
+func (j *journal) JournalAccessListAddAccount(addr common.Address) {
+	j.append(accessListAddAccountChange{&addr})
+}
+
+func (j *journal) JournalAccessListAddSlot(addr common.Address, slot common.Hash) {
+	j.append(accessListAddSlotChange{
+		address: &addr,
+		slot:    &slot,
+	})
+}
+
+func (j *journal) JournalLog(txHash common.Hash) {
+	j.append(addLogChange{txhash: txHash})
+}
+
+func (j *journal) JournalAddPreimage(hash common.Hash) {
+	j.append(addPreimageChange{hash: hash})
+}
+
+func (j *journal) JournalRefund(prev uint64) {
+	j.append(refundChange{prev: prev})
+}
+
+func (j *journal) JournalCreate(addr common.Address) {
+	j.append(createObjectChange{account: &addr})
+}
+
+func (j *journal) JournalDestruct(addr common.Address, previouslyDestructed bool, prevBalance *uint256.Int) {
+	j.append(selfDestructChange{
+		account:     &addr,
+		prev:        previouslyDestructed,
+		prevbalance: prevBalance.Clone(),
+	})
+}
+
+func (j *journal) JournalSetState(addr common.Address, key, prev common.Hash) {
+	j.append(storageChange{
+		account:  &addr,
+		key:      key,
+		prevalue: prev,
+	})
+}
+
+func (j *journal) JournalSetTransientState(addr common.Address, key, prev common.Hash) {
+	j.append(transientStorageChange{
+		account:  &addr,
+		key:      key,
+		prevalue: prev,
+	})
+}
+
+func (j *journal) JournalRefundChange(previous uint64) {
+	j.append(refundChange{prev: previous})
+}
+
+func (j *journal) JournalBalanceChange(addr common.Address, previous *uint256.Int) {
+	j.append(balanceChange{
+		account: &addr,
+		prev:    previous.Clone(),
+	})
+}
+
+func (j *journal) JournalSetCode(address common.Address, prevcode, prevHash []byte) {
+	j.append(codeChange{
+		account:  &address,
+		prevhash: prevHash,
+		prevcode: prevcode,
+	})
+}
+
+func (j *journal) JournalNonceChange(address common.Address, prev uint64) {
+	j.append(nonceChange{
+		account: &address,
+		prev:    prev,
+	})
+}
+
+func (j *journal) JournalTouch(address common.Address) {
+	j.append(touchChange{
+		account: &address,
+	})
+	if address == ripemd {
+		// Explicitly put it in the dirty-cache, which is otherwise generated from
+		// flattened journals.
+		j.dirty(address)
+	}
+}
+
+func (j *journal) JournalReset(address common.Address,
+	prev *stateObject,
+	prevdestruct bool,
+	prevAccount []byte,
+	prevStorage map[common.Hash][]byte,
+	prevAccountOriginExist bool,
+	prevAccountOrigin []byte,
+	prevStorageOrigin map[common.Hash][]byte) {
+
+	j.append(resetObjectChange{
+		account:                &address,
+		prev:                   prev,
+		prevdestruct:           prevdestruct,
+		prevAccount:            prevAccount,
+		prevStorage:            prevStorage,
+		prevAccountOriginExist: prevAccountOriginExist,
+		prevAccountOrigin:      prevAccountOrigin,
+		prevStorageOrigin:      prevStorageOrigin,
+	})
+}
+
 type (
 	// Changes to the account trie.
 	createObjectChange struct {

core/state/state_object.go

@@ -128,14 +128,7 @@ func (s *stateObject) markSelfdestructed() {
 }
 
 func (s *stateObject) touch() {
-	s.db.journal.append(touchChange{
-		account: &s.address,
-	})
-	if s.address == ripemd {
-		// Explicitly put it in the dirty-cache, which is otherwise generated from
-		// flattened journals.
-		s.db.journal.dirty(s.address)
-	}
+	s.db.journal.JournalTouch(s.address)
 }
 
 // getTrie returns the associated storage trie. The trie will be opened
@@ -238,11 +231,7 @@ func (s *stateObject) SetState(key, value common.Hash) {
 		return
 	}
 	// New value is different, update and journal the change
-	s.db.journal.append(storageChange{
-		account:  &s.address,
-		key:      key,
-		prevalue: prev,
-	})
+	s.db.journal.JournalSetState(s.address, key, prev)
 	s.setState(key, value)
 }
 
@@ -427,10 +416,7 @@ func (s *stateObject) SubBalance(amount *uint256.Int) {
 }
 
 func (s *stateObject) SetBalance(amount *uint256.Int) {
-	s.db.journal.append(balanceChange{
-		account: &s.address,
-		prev:    new(uint256.Int).Set(s.data.Balance),
-	})
+	s.db.journal.JournalBalanceChange(s.address, s.data.Balance)
 	s.setBalance(amount)
 }
 
@@ -502,12 +488,7 @@ func (s *stateObject) CodeSize() int {
 }
 
 func (s *stateObject) SetCode(codeHash common.Hash, code []byte) {
-	prevcode := s.Code()
-	s.db.journal.append(codeChange{
-		account:  &s.address,
-		prevhash: s.CodeHash(),
-		prevcode: prevcode,
-	})
+	s.db.journal.JournalSetCode(s.address, s.Code(), s.CodeHash())
 	s.setCode(codeHash, code)
 }
 
@@ -518,10 +499,7 @@ func (s *stateObject) setCode(codeHash common.Hash, code []byte) {
 }
 
 func (s *stateObject) SetNonce(nonce uint64) {
-	s.db.journal.append(nonceChange{
-		account: &s.address,
-		prev:    s.data.Nonce,
-	})
+	s.db.journal.JournalNonceChange(s.address, s.data.Nonce)
 	s.setNonce(nonce)
 }
 

core/state/statedb.go

@@ -207,7 +207,7 @@ func (s *StateDB) Error() error {
 }
 
 func (s *StateDB) AddLog(log *types.Log) {
-	s.journal.append(addLogChange{txhash: s.thash})
+	s.journal.JournalLog(s.thash)
 
 	log.TxHash = s.thash
 	log.TxIndex = uint(s.txIndex)
@@ -238,7 +238,7 @@ func (s *StateDB) Logs() []*types.Log {
 // AddPreimage records a SHA3 preimage seen by the VM.
 func (s *StateDB) AddPreimage(hash common.Hash, preimage []byte) {
 	if _, ok := s.preimages[hash]; !ok {
-		s.journal.append(addPreimageChange{hash: hash})
+		s.journal.JournalAddPreimage(hash)
 		pi := make([]byte, len(preimage))
 		copy(pi, preimage)
 		s.preimages[hash] = pi
@@ -252,14 +252,14 @@ func (s *StateDB) Preimages() map[common.Hash][]byte {
 
 // AddRefund adds gas to the refund counter
 func (s *StateDB) AddRefund(gas uint64) {
-	s.journal.append(refundChange{prev: s.refund})
+	s.journal.JournalRefund(s.refund)
 	s.refund += gas
 }
 
 // SubRefund removes gas from the refund counter.
 // This method will panic if the refund counter goes below zero
 func (s *StateDB) SubRefund(gas uint64) {
-	s.journal.append(refundChange{prev: s.refund})
+	s.journal.JournalRefundChange(s.refund)
 	if gas > s.refund {
 		panic(fmt.Sprintf("Refund counter below zero (gas: %d > refund: %d)", gas, s.refund))
 	}
@@ -447,11 +447,7 @@ func (s *StateDB) SelfDestruct(addr common.Address) {
 	if stateObject == nil {
 		return
 	}
-	s.journal.append(selfDestructChange{
-		account:     &addr,
-		prev:        stateObject.selfDestructed,
-		prevbalance: new(uint256.Int).Set(stateObject.Balance()),
-	})
+	s.journal.JournalDestruct(addr, stateObject.selfDestructed, stateObject.Balance())
 	stateObject.markSelfdestructed()
 	stateObject.data.Balance = new(uint256.Int)
 }
@@ -475,11 +471,7 @@ func (s *StateDB) SetTransientState(addr common.Address, key, value common.Hash)
 	if prev == value {
 		return
 	}
-	s.journal.append(transientStorageChange{
-		account:  &addr,
-		key:      key,
-		prevalue: prev,
-	})
+	s.journal.JournalSetTransientState(addr, key, prev)
 	s.setTransientState(addr, key, value)
 }
 
@@ -629,7 +621,7 @@ 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, nil)
 	if prev == nil {
-		s.journal.append(createObjectChange{account: &addr})
+		s.journal.JournalCreate(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
@@ -643,16 +635,10 @@ func (s *StateDB) createObject(addr common.Address) (newobj, prev *stateObject)
 		// will be called for each transaction before byzantium fork which will always
 		// cache the latest account/storage data.
 		prevAccount, ok := s.accountsOrigin[prev.address]
-		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.address],
-		})
+		s.journal.JournalReset(addr, prev, prevdestruct,
+			s.accounts[prev.addrHash], s.storages[prev.addrHash], ok,
+			prevAccount, s.storagesOrigin[prev.address])
+
 		delete(s.accounts, prev.addrHash)
 		delete(s.storages, prev.addrHash)
 		delete(s.accountsOrigin, prev.address)
@@ -1342,7 +1328,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.JournalAccessListAddAccount(addr)
 	}
 }
 
@@ -1354,13 +1340,10 @@ 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.JournalAccessListAddAccount(addr)
 	}
 	if slotMod {
-		s.journal.append(accessListAddSlotChange{
-			address: &addr,
-			slot:    &slot,
-		})
+		s.journal.JournalAccessListAddSlot(addr, slot)
 	}
 }