all: refactor trie API

core/rawdb/accessors_indexes_test.go

@@ -45,9 +45,10 @@ func (h *testHasher) Reset() {
  h.hasher.Reset()
 }
 
-func (h *testHasher) Update(key, val []byte) {
+func (h *testHasher) Update(key, val []byte) error {
  h.hasher.Write(key)
  h.hasher.Write(val)
+ return nil
 }
 
 func (h *testHasher) Hash() common.Hash {

core/state/snapshot/conversion.go

@@ -371,7 +371,7 @@ func stackTrieGenerate(db ethdb.KeyValueWriter, scheme string, owner common.Hash
  }
  t := trie.NewStackTrieWithOwner(nodeWriter, owner)
  for leaf := range in {
- t.TryUpdate(leaf.key[:], leaf.value)
+ t.Update(leaf.key[:], leaf.value)
  }
  var root common.Hash
  if db == nil {

core/state/snapshot/generate.go

@@ -230,7 +230,7 @@ func (dl *diskLayer) proveRange(ctx *generatorContext, trieId *trie.ID, prefix [
  if origin == nil && !diskMore {
  stackTr := trie.NewStackTrie(nil)
  for i, key := range keys {
- stackTr.TryUpdate(key, vals[i])
+ stackTr.Update(key, vals[i])
  }
  if gotRoot := stackTr.Hash(); gotRoot != root {
  return &proofResult{

core/state/snapshot/generate_test.go

@@ -161,7 +161,7 @@ func newHelper() *testHelper {
 
 func (t *testHelper) addTrieAccount(acckey string, acc *Account) {
  val, _ := rlp.EncodeToBytes(acc)
- t.accTrie.Update([]byte(acckey), val)
+ t.accTrie.MustUpdate([]byte(acckey), val)
 }
 
 func (t *testHelper) addSnapAccount(acckey string, acc *Account) {
@@ -186,7 +186,7 @@ func (t *testHelper) makeStorageTrie(stateRoot, owner common.Hash, keys []string
  id := trie.StorageTrieID(stateRoot, owner, common.Hash{})
  stTrie, _ := trie.NewStateTrie(id, t.triedb)
  for i, k := range keys {
- stTrie.Update([]byte(k), []byte(vals[i]))
+ stTrie.MustUpdate([]byte(k), []byte(vals[i]))
  }
  if !commit {
  return stTrie.Hash().Bytes()
@@ -491,7 +491,7 @@ func TestGenerateWithExtraAccounts(t *testing.T) {
  )
  acc := &Account{Balance: big.NewInt(1), Root: stRoot, CodeHash: types.EmptyCodeHash.Bytes()}
  val, _ := rlp.EncodeToBytes(acc)
- helper.accTrie.Update([]byte("acc-1"), val) // 0x9250573b9c18c664139f3b6a7a8081b7d8f8916a8fcc5d94feec6c29f5fd4e9e
+ helper.accTrie.MustUpdate([]byte("acc-1"), val) // 0x9250573b9c18c664139f3b6a7a8081b7d8f8916a8fcc5d94feec6c29f5fd4e9e
 
  // Identical in the snap
  key := hashData([]byte("acc-1"))
@@ -562,7 +562,7 @@ func TestGenerateWithManyExtraAccounts(t *testing.T) {
  )
  acc := &Account{Balance: big.NewInt(1), Root: stRoot, CodeHash: types.EmptyCodeHash.Bytes()}
  val, _ := rlp.EncodeToBytes(acc)
- helper.accTrie.Update([]byte("acc-1"), val) // 0x9250573b9c18c664139f3b6a7a8081b7d8f8916a8fcc5d94feec6c29f5fd4e9e
+ helper.accTrie.MustUpdate([]byte("acc-1"), val) // 0x9250573b9c18c664139f3b6a7a8081b7d8f8916a8fcc5d94feec6c29f5fd4e9e
 
  // Identical in the snap
  key := hashData([]byte("acc-1"))
@@ -613,8 +613,8 @@ func TestGenerateWithExtraBeforeAndAfter(t *testing.T) {
  {
  acc := &Account{Balance: big.NewInt(1), Root: types.EmptyRootHash.Bytes(), CodeHash: types.EmptyCodeHash.Bytes()}
  val, _ := rlp.EncodeToBytes(acc)
- helper.accTrie.Update(common.HexToHash("0x03").Bytes(), val)
- helper.accTrie.Update(common.HexToHash("0x07").Bytes(), val)
+ helper.accTrie.MustUpdate(common.HexToHash("0x03").Bytes(), val)
+ helper.accTrie.MustUpdate(common.HexToHash("0x07").Bytes(), val)
 
  rawdb.WriteAccountSnapshot(helper.diskdb, common.HexToHash("0x01"), val)
  rawdb.WriteAccountSnapshot(helper.diskdb, common.HexToHash("0x02"), val)
@@ -650,7 +650,7 @@ func TestGenerateWithMalformedSnapdata(t *testing.T) {
  {
  acc := &Account{Balance: big.NewInt(1), Root: types.EmptyRootHash.Bytes(), CodeHash: types.EmptyCodeHash.Bytes()}
  val, _ := rlp.EncodeToBytes(acc)
- helper.accTrie.Update(common.HexToHash("0x03").Bytes(), val)
+ helper.accTrie.MustUpdate(common.HexToHash("0x03").Bytes(), val)
 
  junk := make([]byte, 100)
  copy(junk, []byte{0xde, 0xad})

core/state/sync_test.go

@@ -213,22 +213,22 @@ func testIterativeStateSync(t *testing.T, count int, commit bool, bypath bool) {
  for i, node := range nodeElements {
  if bypath {
  if len(node.syncPath) == 1 {
- data, _, err := srcTrie.TryGetNode(node.syncPath[0])
+ data, _, err := srcTrie.GetNode(node.syncPath[0])
  if err != nil {
  t.Fatalf("failed to retrieve node data for path %x: %v", node.syncPath[0], err)
  }
  nodeResults[i] = trie.NodeSyncResult{Path: node.path, Data: data}
  } else {
  var acc types.StateAccount
- if err := rlp.DecodeBytes(srcTrie.Get(node.syncPath[0]), &acc); err != nil {
+ if err := rlp.DecodeBytes(srcTrie.MustGet(node.syncPath[0]), &acc); err != nil {
  t.Fatalf("failed to decode account on path %x: %v", node.syncPath[0], err)
  }
  id := trie.StorageTrieID(srcRoot, common.BytesToHash(node.syncPath[0]), acc.Root)
  stTrie, err := trie.New(id, srcDb.TrieDB())
  if err != nil {
  t.Fatalf("failed to retriev storage trie for path %x: %v", node.syncPath[1], err)
  }
- data, _, err := stTrie.TryGetNode(node.syncPath[1])
+ data, _, err := stTrie.GetNode(node.syncPath[1])
  if err != nil {
  t.Fatalf("failed to retrieve node data for path %x: %v", node.syncPath[1], err)
  }

core/types/block_test.go

@@ -232,9 +232,10 @@ func (h *testHasher) Reset() {
  h.hasher.Reset()
 }
 
-func (h *testHasher) Update(key, val []byte) {
+func (h *testHasher) Update(key, val []byte) error {
  h.hasher.Write(key)
  h.hasher.Write(val)
+ return nil
 }
 
 func (h *testHasher) Hash() common.Hash {

core/types/hashing.go

@@ -62,7 +62,7 @@ func prefixedRlpHash(prefix byte, x interface{}) (h common.Hash) {
 // This is internal, do not use.
 type TrieHasher interface {
  Reset()
- Update([]byte, []byte)
+ Update([]byte, []byte) error
  Hash() common.Hash
 }
 
@@ -93,6 +93,9 @@ func DeriveSha(list DerivableList, hasher TrieHasher) common.Hash {
  // StackTrie requires values to be inserted in increasing hash order, which is not the
  // order that `list` provides hashes in. This insertion sequence ensures that the
  // order is correct.
+ //
+ // The error returned by hasher is omitted because hasher will produce an incorrect
+ // hash in case any error occurs.
  var indexBuf []byte
  for i := 1; i < list.Len() && i <= 0x7f; i++ {
  indexBuf = rlp.AppendUint64(indexBuf[:0], uint64(i))

core/types/hashing_test.go

@@ -219,9 +219,10 @@ func (d *hashToHumanReadable) Reset() {
  d.data = make([]byte, 0)
 }
 
-func (d *hashToHumanReadable) Update(i []byte, i2 []byte) {
+func (d *hashToHumanReadable) Update(i []byte, i2 []byte) error {
  l := fmt.Sprintf("%x %x\n", i, i2)
  d.data = append(d.data, []byte(l)...)
+ return nil
 }
 
 func (d *hashToHumanReadable) Hash() common.Hash {

eth/protocols/snap/sync_test.go

@@ -216,7 +216,7 @@ func defaultTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash,
  for _, pathset := range paths {
  switch len(pathset) {
  case 1:
- blob, _, err := t.accountTrie.TryGetNode(pathset[0])
+ blob, _, err := t.accountTrie.GetNode(pathset[0])
  if err != nil {
  t.logger.Info("Error handling req", "error", err)
  break
@@ -225,7 +225,7 @@ func defaultTrieRequestHandler(t *testPeer, requestId uint64, root common.Hash,
  default:
  account := t.storageTries[(common.BytesToHash(pathset[0]))]
  for _, path := range pathset[1:] {
- blob, _, err := account.TryGetNode(path)
+ blob, _, err := account.GetNode(path)
  if err != nil {
  t.logger.Info("Error handling req", "error", err)
  break
@@ -1381,7 +1381,7 @@ func makeAccountTrieNoStorage(n int) (string, *trie.Trie, entrySlice) {
  })
  key := key32(i)
  elem := &kv{key, value}
- accTrie.Update(elem.k, elem.v)
+ accTrie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  sort.Sort(entries)
@@ -1431,7 +1431,7 @@ func makeBoundaryAccountTrie(n int) (string, *trie.Trie, entrySlice) {
  CodeHash: getCodeHash(uint64(i)),
  })
  elem := &kv{boundaries[i].Bytes(), value}
- accTrie.Update(elem.k, elem.v)
+ accTrie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  // Fill other accounts if required
@@ -1443,7 +1443,7 @@ func makeBoundaryAccountTrie(n int) (string, *trie.Trie, entrySlice) {
  CodeHash: getCodeHash(i),
  })
  elem := &kv{key32(i), value}
- accTrie.Update(elem.k, elem.v)
+ accTrie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  sort.Sort(entries)
@@ -1487,7 +1487,7 @@ func makeAccountTrieWithStorageWithUniqueStorage(accounts, slots int, code bool)
  CodeHash: codehash,
  })
  elem := &kv{key, value}
- accTrie.Update(elem.k, elem.v)
+ accTrie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
 
  storageRoots[common.BytesToHash(key)] = stRoot
@@ -1551,7 +1551,7 @@ func makeAccountTrieWithStorage(accounts, slots int, code, boundary bool) (strin
  CodeHash: codehash,
  })
  elem := &kv{key, value}
- accTrie.Update(elem.k, elem.v)
+ accTrie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
 
  // we reuse the same one for all accounts
@@ -1599,7 +1599,7 @@ func makeStorageTrieWithSeed(owner common.Hash, n, seed uint64, db *trie.Databas
  key := crypto.Keccak256Hash(slotKey[:])
 
  elem := &kv{key[:], rlpSlotValue}
- trie.Update(elem.k, elem.v)
+ trie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  sort.Sort(entries)
@@ -1638,7 +1638,7 @@ func makeBoundaryStorageTrie(owner common.Hash, n int, db *trie.Database) (commo
  val := []byte{0xde, 0xad, 0xbe, 0xef}
 
  elem := &kv{key[:], val}
- trie.Update(elem.k, elem.v)
+ trie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  // Fill other slots if required
@@ -1650,7 +1650,7 @@ func makeBoundaryStorageTrie(owner common.Hash, n int, db *trie.Database) (commo
  rlpSlotValue, _ := rlp.EncodeToBytes(common.TrimLeftZeroes(slotValue[:]))
 
  elem := &kv{key[:], rlpSlotValue}
- trie.Update(elem.k, elem.v)
+ trie.MustUpdate(elem.k, elem.v)
  entries = append(entries, elem)
  }
  sort.Sort(entries)

les/server_handler.go

@@ -364,7 +364,7 @@ func getAccount(triedb *trie.Database, root, hash common.Hash) (types.StateAccou
  if err != nil {
  return types.StateAccount{}, err
  }
- blob, err := trie.TryGet(hash[:])
+ blob, err := trie.Get(hash[:])
  if err != nil {
  return types.StateAccount{}, err
  }

light/postprocess.go

@@ -206,8 +206,7 @@ func (c *ChtIndexerBackend) Process(ctx context.Context, header *types.Header) e
  var encNumber [8]byte
  binary.BigEndian.PutUint64(encNumber[:], num)
  data, _ := rlp.EncodeToBytes(ChtNode{hash, td})
- c.trie.Update(encNumber[:], data)
- return nil
+ return c.trie.Update(encNumber[:], data)
 }
 
 // Commit implements core.ChainIndexerBackend
@@ -450,10 +449,15 @@ func (b *BloomTrieIndexerBackend) Commit() error {
 
  decompSize += uint64(len(decomp))
  compSize += uint64(len(comp))
+
+ var terr error
  if len(comp) > 0 {
- b.trie.Update(encKey[:], comp)
+ terr = b.trie.Update(encKey[:], comp)
  } else {
- b.trie.Delete(encKey[:])
+ terr = b.trie.Delete(encKey[:])
+ }
+ if terr != nil {
+ return terr
  }
  }
  root, nodes := b.trie.Commit(false)

light/trie.go

@@ -109,7 +109,7 @@ func (t *odrTrie) GetStorage(_ common.Address, key []byte) ([]byte, error) {
  key = crypto.Keccak256(key)
  var res []byte
  err := t.do(key, func() (err error) {
- res, err = t.trie.TryGet(key)
+ res, err = t.trie.Get(key)
  return err
  })
  return res, err
@@ -119,7 +119,7 @@ func (t *odrTrie) GetAccount(address common.Address) (*types.StateAccount, error
  var res types.StateAccount
  key := crypto.Keccak256(address.Bytes())
  err := t.do(key, func() (err error) {
- value, err := t.trie.TryGet(key)
+ value, err := t.trie.Get(key)
  if err != nil {
  return err
  }
@@ -138,29 +138,29 @@ func (t *odrTrie) UpdateAccount(address common.Address, acc *types.StateAccount)
  return fmt.Errorf("decoding error in account update: %w", err)
  }
  return t.do(key, func() error {
- return t.trie.TryUpdate(key, value)
+ return t.trie.Update(key, value)
  })
 }
 
 func (t *odrTrie) UpdateStorage(_ common.Address, key, value []byte) error {
  key = crypto.Keccak256(key)
  return t.do(key, func() error {
- return t.trie.TryUpdate(key, value)
+ return t.trie.Update(key, value)
  })
 }
 
 func (t *odrTrie) DeleteStorage(_ common.Address, key []byte) error {
  key = crypto.Keccak256(key)
  return t.do(key, func() error {
- return t.trie.TryDelete(key)
+ return t.trie.Delete(key)
  })
 }
 
 // TryDeleteAccount abstracts an account deletion from the trie.
 func (t *odrTrie) DeleteAccount(address common.Address) error {
  key := crypto.Keccak256(address.Bytes())
  return t.do(key, func() error {
- return t.trie.TryDelete(key)
+ return t.trie.Delete(key)
  })
 }
 

tests/fuzzers/les/les-fuzzer.go

@@ -93,13 +93,13 @@ func makeTries() (chtTrie *trie.Trie, bloomTrie *trie.Trie, chtKeys, bloomKeys [
  // The element in CHT is <big-endian block number> -> <block hash>
  key := make([]byte, 8)
  binary.BigEndian.PutUint64(key, uint64(i+1))
- chtTrie.Update(key, []byte{0x1, 0xf})
+ chtTrie.MustUpdate(key, []byte{0x1, 0xf})
  chtKeys = append(chtKeys, key)
 
  // The element in Bloom trie is <2 byte bit index> + <big-endian block number> -> bloom
  key2 := make([]byte, 10)
  binary.BigEndian.PutUint64(key2[2:], uint64(i+1))
- bloomTrie.Update(key2, []byte{0x2, 0xe})
+ bloomTrie.MustUpdate(key2, []byte{0x2, 0xe})
  bloomKeys = append(bloomKeys, key2)
  }
  return

tests/fuzzers/rangeproof/rangeproof-fuzzer.go

@@ -69,8 +69,8 @@ func (f *fuzzer) randomTrie(n int) (*trie.Trie, map[string]*kv) {
  for i := byte(0); i < byte(size); i++ {
  value := &kv{common.LeftPadBytes([]byte{i}, 32), []byte{i}, false}
  value2 := &kv{common.LeftPadBytes([]byte{i + 10}, 32), []byte{i}, false}
- trie.Update(value.k, value.v)
- trie.Update(value2.k, value2.v)
+ trie.MustUpdate(value.k, value.v)
+ trie.MustUpdate(value2.k, value2.v)
  vals[string(value.k)] = value
  vals[string(value2.k)] = value2
  }
@@ -82,7 +82,7 @@ func (f *fuzzer) randomTrie(n int) (*trie.Trie, map[string]*kv) {
  k := f.randBytes(32)
  v := f.randBytes(20)
  value := &kv{k, v, false}
- trie.Update(k, v)
+ trie.MustUpdate(k, v)
  vals[string(k)] = value
  if f.exhausted {
  return nil, nil

tests/fuzzers/stacktrie/trie_fuzzer.go

@@ -175,7 +175,7 @@ func (f *fuzzer) fuzz() int {
  }
  keys[string(k)] = struct{}{}
  vals = append(vals, kv{k: k, v: v})
- trieA.Update(k, v)
+ trieA.MustUpdate(k, v)
  useful = true
  }
  if !useful {
@@ -195,7 +195,7 @@ func (f *fuzzer) fuzz() int {
  if f.debugging {
  fmt.Printf("{\"%#x\" , \"%#x\"} // stacktrie.Update\n", kv.k, kv.v)
  }
- trieB.Update(kv.k, kv.v)
+ trieB.MustUpdate(kv.k, kv.v)
  }
  rootB := trieB.Hash()
  trieB.Commit()
@@ -223,7 +223,7 @@ func (f *fuzzer) fuzz() int {
  checked int
  )
  for _, kv := range vals {
- trieC.Update(kv.k, kv.v)
+ trieC.MustUpdate(kv.k, kv.v)
  }
  rootC, _ := trieC.Commit()
  if rootA != rootC {