forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-17 18:30:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

trie: fix some typos #25551 #25648 (#1111)

Browse source
This commit is contained in:
Daniel Liu 2025-09-21 18:51:15 +08:00 committed by GitHub
parent 1f6bd2bae5
commit 0b13b19b55
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 19 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
trie/database.go
View file

@ -162,7 +162,7 @@ func (n *cachedNode) rlp() []byte {
// or by regenerating it from the rlp encoded blob. // or by regenerating it from the rlp encoded blob.
func (n *cachedNode) obj(hash common.Hash) node { func (n *cachedNode) obj(hash common.Hash) node {
if node, ok := n.node.(rawNode); ok { if node, ok := n.node.(rawNode); ok {
// The raw-blob format nodes are loaded from either from // The raw-blob format nodes are loaded either from the
// clean cache or the database, they are all in their own // clean cache or the database, they are all in their own
// copy and safe to use unsafe decoder. // copy and safe to use unsafe decoder.
return mustDecodeNodeUnsafe(hash[:], node) return mustDecodeNodeUnsafe(hash[:], node)

2
trie/hasher.go
View file

@ -191,7 +191,7 @@ func (h *hasher) hashData(data []byte) hashNode {
} }
// proofHash is used to construct trie proofs, and returns the 'collapsed' // proofHash is used to construct trie proofs, and returns the 'collapsed'
// Node (for later RLP encoding) aswell as the hashed Node -- unless the // Node (for later RLP encoding) as well as the hashed Node -- unless the
// Node is smaller than 32 bytes, in which case it will be returned as is. // Node is smaller than 32 bytes, in which case it will be returned as is.
// This method does not do anything on value- or hash-nodes. // This method does not do anything on value- or hash-nodes.
func (h *hasher) proofHash(original node) (collapsed, hashed node) { func (h *hasher) proofHash(original node) (collapsed, hashed node) {

32
trie/proof_test.go
View file

@ -200,7 +200,7 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
proof := memorydb.New() proof := memorydb.New()
// Short circuit if the decreased key is same with the previous key // Short circuit if the decreased key is same with the previous key
first := decreseKey(common.CopyBytes(entries[start].k)) first := decreaseKey(common.CopyBytes(entries[start].k))
if start != 0 && bytes.Equal(first, entries[start-1].k) { if start != 0 && bytes.Equal(first, entries[start-1].k) {
continue continue
} }
@ -209,7 +209,7 @@ func TestRangeProofWithNonExistentProof(t *testing.T) {
continue continue
} }
// Short circuit if the increased key is same with the next key // Short circuit if the increased key is same with the next key
last := increseKey(common.CopyBytes(entries[end-1].k)) last := increaseKey(common.CopyBytes(entries[end-1].k))
if end != len(entries) && bytes.Equal(last, entries[end].k) { if end != len(entries) && bytes.Equal(last, entries[end].k) {
continue continue
} }
@ -269,7 +269,7 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
// Case 1 // Case 1
start, end := 100, 200 start, end := 100, 200
first := decreseKey(common.CopyBytes(entries[start].k)) first := decreaseKey(common.CopyBytes(entries[start].k))
proof := memorydb.New() proof := memorydb.New()
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
@ -292,7 +292,7 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) {
// Case 2 // Case 2
start, end = 100, 200 start, end = 100, 200
last := increseKey(common.CopyBytes(entries[end-1].k)) last := increaseKey(common.CopyBytes(entries[end-1].k))
proof = memorydb.New() proof = memorydb.New()
if err := trie.Prove(entries[start].k, 0, proof); err != nil { if err := trie.Prove(entries[start].k, 0, proof); err != nil {
t.Fatalf("Failed to prove the first node %v", err) t.Fatalf("Failed to prove the first node %v", err)
@ -338,7 +338,7 @@ func TestOneElementRangeProof(t *testing.T) {
// One element with left non-existent edge proof // One element with left non-existent edge proof
start = 1000 start = 1000
first := decreseKey(common.CopyBytes(entries[start].k)) first := decreaseKey(common.CopyBytes(entries[start].k))
proof = memorydb.New() proof = memorydb.New()
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
t.Fatalf("Failed to prove the first node %v", err) t.Fatalf("Failed to prove the first node %v", err)
@ -353,7 +353,7 @@ func TestOneElementRangeProof(t *testing.T) {
// One element with right non-existent edge proof // One element with right non-existent edge proof
start = 1000 start = 1000
last := increseKey(common.CopyBytes(entries[start].k)) last := increaseKey(common.CopyBytes(entries[start].k))
proof = memorydb.New() proof = memorydb.New()
if err := trie.Prove(entries[start].k, 0, proof); err != nil { if err := trie.Prove(entries[start].k, 0, proof); err != nil {
t.Fatalf("Failed to prove the first node %v", err) t.Fatalf("Failed to prove the first node %v", err)
@ -368,7 +368,7 @@ func TestOneElementRangeProof(t *testing.T) {
// One element with two non-existent edge proofs // One element with two non-existent edge proofs
start = 1000 start = 1000
first, last = decreseKey(common.CopyBytes(entries[start].k)), increseKey(common.CopyBytes(entries[start].k)) first, last = decreaseKey(common.CopyBytes(entries[start].k)), increaseKey(common.CopyBytes(entries[start].k))
proof = memorydb.New() proof = memorydb.New()
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
t.Fatalf("Failed to prove the first node %v", err) t.Fatalf("Failed to prove the first node %v", err)
@ -636,9 +636,9 @@ func TestSameSideProofs(t *testing.T) {
sort.Sort(entries) sort.Sort(entries)
pos := 1000 pos := 1000
first := decreseKey(common.CopyBytes(entries[pos].k)) first := decreaseKey(common.CopyBytes(entries[pos].k))
first = decreseKey(first) first = decreaseKey(first)
last := decreseKey(common.CopyBytes(entries[pos].k)) last := decreaseKey(common.CopyBytes(entries[pos].k))
proof := memorydb.New() proof := memorydb.New()
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
@ -652,9 +652,9 @@ func TestSameSideProofs(t *testing.T) {
t.Fatalf("Expected error, got nil") t.Fatalf("Expected error, got nil")
} }
first = increseKey(common.CopyBytes(entries[pos].k)) first = increaseKey(common.CopyBytes(entries[pos].k))
last = increseKey(common.CopyBytes(entries[pos].k)) last = increaseKey(common.CopyBytes(entries[pos].k))
last = increseKey(last) last = increaseKey(last)
proof = memorydb.New() proof = memorydb.New()
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
@ -760,7 +760,7 @@ func TestEmptyRangeProof(t *testing.T) {
} }
for _, c := range cases { for _, c := range cases {
proof := memorydb.New() proof := memorydb.New()
first := increseKey(common.CopyBytes(entries[c.pos].k)) first := increaseKey(common.CopyBytes(entries[c.pos].k))
if err := trie.Prove(first, 0, proof); err != nil { if err := trie.Prove(first, 0, proof); err != nil {
t.Fatalf("Failed to prove the first node %v", err) t.Fatalf("Failed to prove the first node %v", err)
} }
@ -899,7 +899,7 @@ func mutateByte(b []byte) {
} }
} }
func increseKey(key []byte) []byte { func increaseKey(key []byte) []byte {
for i := len(key) - 1; i >= 0; i-- { for i := len(key) - 1; i >= 0; i-- {
key[i]++ key[i]++
if key[i] != 0x0 { if key[i] != 0x0 {
@ -909,7 +909,7 @@ func increseKey(key []byte) []byte {
return key return key
} }
func decreseKey(key []byte) []byte { func decreaseKey(key []byte) []byte {
for i := len(key) - 1; i >= 0; i-- { for i := len(key) - 1; i >= 0; i-- {
key[i]-- key[i]--
if key[i] != 0xff { if key[i] != 0xff {

2
trie/secure_trie_test.go
View file

@ -121,7 +121,7 @@ func TestStateTrieConcurrency(t *testing.T) {
for i := 0; i < threads; i++ { for i := 0; i < threads; i++ {
tries[i] = trie.Copy() tries[i] = trie.Copy()
} }
// Start a batch of goroutines interactng with the trie // Start a batch of goroutines interacting with the trie
pend := new(sync.WaitGroup) pend := new(sync.WaitGroup)
pend.Add(threads) pend.Add(threads)
for i := 0; i < threads; i++ { for i := 0; i < threads; i++ {