forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-06-18 21:01:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

trie/bintrie: merge makeKeyPath into keyToPath

Browse source 
Drop the panic-on-error variant. All callers are inside methods
that already propagate errors, so the error-returning form is the
right default.
This commit is contained in:
CPerezz 2026-04-17 10:32:14 +02:00
parent 84c61897b3
commit b3b86a873a
No known key found for this signature in database
GPG key ID: 62045F34B97177DD
2 changed files with 20 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
trie/bintrie/internal_node.go
View file

@ -34,16 +34,6 @@ func keyToPath(depth int, key []byte) ([]byte, error) {
return path, nil return path, nil
} }
// makeKeyPath is like keyToPath but panics on invalid depth.
func makeKeyPath(depth int, key []byte) []byte {
path := make([]byte, 0, depth+1)
for i := range depth + 1 {
bit := key[i/8] >> (7 - (i % 8)) & 1
path = append(path, bit)
}
return path
}
type InternalNode struct { type InternalNode struct {
left, right NodeRef left, right NodeRef
depth uint8 depth uint8

25
trie/bintrie/store_ops.go
View file

@ -71,7 +71,10 @@ func (s *NodeStore) getSingle(ref NodeRef, stem []byte, suffix byte, resolver No
} }
hn := s.getHashed(cur.Index()) hn := s.getHashed(cur.Index())
parentNode := s.getInternal(parentIdx) parentNode := s.getInternal(parentIdx)
path := makeKeyPath(int(parentNode.depth), stem) path, err := keyToPath(int(parentNode.depth), stem)
if err != nil {
return nil, fmt.Errorf("getSingle path error: %w", err)
}
data, err := resolver(path, hn.Hash()) data, err := resolver(path, hn.Hash())
if err != nil { if err != nil {
return nil, fmt.Errorf("getSingle resolve error: %w", err) return nil, fmt.Errorf("getSingle resolve error: %w", err)
@ -142,7 +145,10 @@ func (s *NodeStore) getValuesAtStem(ref NodeRef, stem []byte, resolver NodeResol
} }
hn := s.getHashed(cur.Index()) hn := s.getHashed(cur.Index())
parentNode := s.getInternal(parentIdx) parentNode := s.getInternal(parentIdx)
path := makeKeyPath(int(parentNode.depth), stem) path, err := keyToPath(int(parentNode.depth), stem)
if err != nil {
return nil, fmt.Errorf("getValuesAtStem path error: %w", err)
}
data, err := resolver(path, hn.Hash()) data, err := resolver(path, hn.Hash())
if err != nil { if err != nil {
return nil, fmt.Errorf("getValuesAtStem resolve error: %w", err) return nil, fmt.Errorf("getValuesAtStem resolve error: %w", err)
@ -250,7 +256,10 @@ func (s *NodeStore) insertSingleInternal(stem []byte, suffix byte, value []byte,
p := pathStack[pathLen-1] p := pathStack[pathLen-1]
parentNode := s.getInternal(p.internalIdx) parentNode := s.getInternal(p.internalIdx)
hn := s.getHashed(cur.Index()) hn := s.getHashed(cur.Index())
path := makeKeyPath(int(parentNode.depth), stem) path, err := keyToPath(int(parentNode.depth), stem)
if err != nil {
return fmt.Errorf("insertSingle path error: %w", err)
}
data, err := resolver(path, hn.Hash()) data, err := resolver(path, hn.Hash())
if err != nil { if err != nil {
return fmt.Errorf("insertSingle resolve error: %w", err) return fmt.Errorf("insertSingle resolve error: %w", err)
@ -369,7 +378,10 @@ func (s *NodeStore) insertValuesAtStem(ref NodeRef, stem []byte, values [][]byte
return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver") return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver")
} }
hn := s.getHashed(node.left.Index()) hn := s.getHashed(node.left.Index())
path := makeKeyPath(int(node.depth), stem) path, err := keyToPath(int(node.depth), stem)
if err != nil {
return ref, fmt.Errorf("InsertValuesAtStem path error: %w", err)
}
data, err := resolver(path, hn.Hash()) data, err := resolver(path, hn.Hash())
if err != nil { if err != nil {
return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)
@ -392,7 +404,10 @@ func (s *NodeStore) insertValuesAtStem(ref NodeRef, stem []byte, values [][]byte
return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver") return ref, errors.New("insertValuesAtStem: cannot resolve hashed node without resolver")
} }
hn := s.getHashed(node.right.Index()) hn := s.getHashed(node.right.Index())
path := makeKeyPath(int(node.depth), stem) path, err := keyToPath(int(node.depth), stem)
if err != nil {
return ref, fmt.Errorf("InsertValuesAtStem path error: %w", err)
}
data, err := resolver(path, hn.Hash()) data, err := resolver(path, hn.Hash())
if err != nil { if err != nil {
return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err) return ref, fmt.Errorf("InsertValuesAtStem resolve error: %w", err)