core: use TryGetAccount to read what TryUpdateAccount has written

core/state/database.go

@@ -71,7 +71,9 @@ type Trie interface {
 	// trie.MissingNodeError is returned.
 	TryGet(key []byte) ([]byte, error)
 
-	// TryUpdateAccount abstract an account write in the trie.
+	TryGetAccount(key []byte) (*types.StateAccount, error)
+
+	// TryUpdateAccount abstract an account write to the trie.
 	TryUpdateAccount(key []byte, account *types.StateAccount) error
 
 	// TryUpdate associates key with value in the trie. If value has length zero, any

core/state/statedb.go

@@ -537,20 +537,16 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
 	// If snapshot unavailable or reading from it failed, load from the database
 	if data == nil {
 		start := time.Now()
-		enc, err := s.trie.TryGet(addr.Bytes())
+		var err error
+		data, err = s.trie.TryGetAccount(addr.Bytes())
 		if metrics.EnabledExpensive {
 			s.AccountReads += time.Since(start)
 		}
 		if err != nil {
-			s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %v", addr.Bytes(), err))
+			s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %w", addr.Bytes(), err))
 			return nil
 		}
-		if len(enc) == 0 {
-			return nil
-		}
-		data = new(types.StateAccount)
-		if err := rlp.DecodeBytes(enc, data); err != nil {
-			log.Error("Failed to decode state object", "addr", addr, "err", err)
+		if data == nil {
 			return nil
 		}
 	}

core/state/trie_prefetcher.go

@@ -331,7 +331,11 @@ func (sf *subfetcher) loop() {
 					if _, ok := sf.seen[string(task)]; ok {
 						sf.dups++
 					} else {
-						sf.trie.TryGet(task)
+						if len(task) == len(common.Address{}) {
+							sf.trie.TryGetAccount(task)
+						} else {
+							sf.trie.TryGet(task)
+						}
 						sf.seen[string(task)] = struct{}{}
 					}
 				}

eth/protocols/snap/handler.go

@@ -30,7 +30,6 @@ import (
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
 )
 
@@ -419,8 +418,9 @@ func ServiceGetStorageRangesQuery(chain *core.BlockChain, req *GetStorageRangesP
 			if err != nil {
 				return nil, nil
 			}
-			var acc types.StateAccount
-			if err := rlp.DecodeBytes(accTrie.Get(account[:]), &acc); err != nil {
+			var acc *types.StateAccount
+			acc, err = accTrie.TryGetAccount(account[:])
+			if err != nil {
 				return nil, nil
 			}
 			stTrie, err := trie.New(account, acc.Root, chain.StateCache().TrieDB())

light/trie.go

@@ -112,6 +112,16 @@ func (t *odrTrie) TryGet(key []byte) ([]byte, error) {
 	return res, err
 }
 
+func (t *odrTrie) TryGetAccount(key []byte) (*types.StateAccount, error) {
+	key = crypto.Keccak256(key)
+	var res *types.StateAccount
+	err := t.do(key, func() (err error) {
+		res, err = t.trie.TryGetAccount(key)
+		return err
+	})
+	return res, err
+}
+
 func (t *odrTrie) TryUpdateAccount(key []byte, acc *types.StateAccount) error {
 	key = crypto.Keccak256(key)
 	value, err := rlp.EncodeToBytes(acc)

trie/secure_trie.go

@@ -82,6 +82,10 @@ func (t *SecureTrie) TryGet(key []byte) ([]byte, error) {
 	return t.trie.TryGet(t.hashKey(key))
 }
 
+func (t *SecureTrie) TryGetAccount(key []byte) (*types.StateAccount, error) {
+	return t.trie.TryGetAccount(t.hashKey(key))
+}
+
 // TryGetNode attempts to retrieve a trie node by compact-encoded path. It is not
 // possible to use keybyte-encoding as the path might contain odd nibbles.
 func (t *SecureTrie) TryGetNode(path []byte) ([]byte, int, error) {
@@ -96,7 +100,7 @@ func (t *SecureTrie) TryUpdateAccount(key []byte, acc *types.StateAccount) error
 	if err != nil {
 		return err
 	}
-	if err := t.trie.TryUpdate(hk, data); err != nil {
+	if err := t.trie.tryUpdate(hk, data); err != nil {
 		return err
 	}
 	t.getSecKeyCache()[string(hk)] = common.CopyBytes(key)

trie/trie.go

@@ -154,6 +154,23 @@ func (t *Trie) Get(key []byte) []byte {
 	return res
 }
 
+func (t *Trie) TryGetAccount(key []byte) (*types.StateAccount, error) {
+	res, newroot, didResolve, err := t.tryGet(t.root, keybytesToHex(key), 0)
+	if err != nil {
+		log.Error(fmt.Sprintf("Unhandled trie error: %v", err))
+		return &types.StateAccount{}, err
+	}
+	if didResolve {
+		t.root = newroot
+	}
+	if res == nil {
+		return nil, nil
+	}
+	var ret types.StateAccount
+	err = rlp.DecodeBytes(res, &ret)
+	return &ret, err
+}
+
 // TryGet returns the value for key stored in the trie.
 // The value bytes must not be modified by the caller.
 // If a node was not found in the database, a MissingNodeError is returned.
@@ -295,7 +312,9 @@ func (t *Trie) TryUpdateAccount(key []byte, acc *types.StateAccount) error {
 	if err != nil {
 		return fmt.Errorf("can't encode object at %x: %w", key[:], err)
 	}
-	return t.TryUpdate(key, data)
+	// Encoding []byte cannot fail, ok to ignore the error.
+	v, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(data[:]))
+	return t.tryUpdate(key, v)
 }
 
 // TryUpdate associates key with value in the trie. Subsequent calls to
@@ -307,6 +326,12 @@ func (t *Trie) TryUpdateAccount(key []byte, acc *types.StateAccount) error {
 //
 // If a node was not found in the database, a MissingNodeError is returned.
 func (t *Trie) TryUpdate(key, value []byte) error {
+	return t.tryUpdate(key, value)
+}
+
+// tryUpdate expects an RLP-encoded value and performs the core function
+// for TryUpdate and TryUpdateAccount.
+func (t *Trie) tryUpdate(key, value []byte) error {
 	t.unhashed++
 	k := keybytesToHex(key)
 	if len(value) != 0 {