From 1d957d21b43a094e221b7645aaa46c8ecf71aaaa Mon Sep 17 00:00:00 2001 From: Quentin McGaw Date: Wed, 2 Nov 2022 11:24:58 +0000 Subject: [PATCH] fix(state): node hashes vs merkle values - Pruners only care about node hashes - Rename variables, functions and methods only dealing with node hashes - Do not write or read inlined nodes with a non-hash Merkle value - Clarify error wrappings and comments --- dot/state/offline_pruner.go | 10 ++--- dot/state/pruner/pruner.go | 66 +++++++++++++++--------------- dot/state/storage.go | 8 ++-- lib/runtime/storage/trie.go | 12 +++--- lib/trie/database.go | 74 ++++++++++++++++++++-------------- lib/trie/database_test.go | 47 ++++++++++++--------- lib/trie/proof/generate.go | 11 +++-- lib/trie/trie.go | 16 ++++---- lib/trie/trie_endtoend_test.go | 12 +++--- lib/trie/trie_test.go | 4 +- 10 files changed, 141 insertions(+), 119 deletions(-) diff --git a/dot/state/offline_pruner.go b/dot/state/offline_pruner.go index 62ceb7b86cf..6d31745f236 100644 --- a/dot/state/offline_pruner.go +++ b/dot/state/offline_pruner.go @@ -105,7 +105,7 @@ func (p *OfflinePruner) SetBloomFilter() (err error) { } latestBlockNum := header.Number - merkleValues := make(map[string]struct{}) + nodeHashes := make(map[common.Hash]struct{}) logger.Infof("Latest block number is %d", latestBlockNum) @@ -121,7 +121,7 @@ func (p *OfflinePruner) SetBloomFilter() (err error) { return err } - trie.PopulateNodeHashes(tr.RootNode(), merkleValues) + trie.PopulateNodeHashes(tr.RootNode(), nodeHashes) // get parent header of current block header, err = p.blockState.GetHeader(header.ParentHash) @@ -131,14 +131,14 @@ func (p *OfflinePruner) SetBloomFilter() (err error) { blockNum = header.Number } - for key := range merkleValues { - err = p.bloom.put([]byte(key)) + for key := range nodeHashes { + err = p.bloom.put(key.ToBytes()) if err != nil { return err } } - logger.Infof("Total keys added in bloom filter: %d", len(merkleValues)) + logger.Infof("Total keys added in bloom filter: %d", len(nodeHashes)) return nil } diff --git a/dot/state/pruner/pruner.go b/dot/state/pruner/pruner.go index c8e2c699945..4d0af8611d9 100644 --- a/dot/state/pruner/pruner.go +++ b/dot/state/pruner/pruner.go @@ -51,7 +51,7 @@ type Config struct { // Pruner is implemented by FullNode and ArchiveNode. type Pruner interface { - StoreJournalRecord(deletedMerkleValues, insertedMerkleValues map[string]struct{}, + StoreJournalRecord(deletedNodeHashes, insertedNodeHashes map[common.Hash]struct{}, blockHash common.Hash, blockNum int64) error } @@ -59,14 +59,14 @@ type Pruner interface { type ArchiveNode struct{} // StoreJournalRecord for archive node doesn't do anything. -func (*ArchiveNode) StoreJournalRecord(_, _ map[string]struct{}, +func (*ArchiveNode) StoreJournalRecord(_, _ map[common.Hash]struct{}, _ common.Hash, _ int64) error { return nil } type deathRecord struct { - blockHash common.Hash - deletedMerkleValueToBlockNumber map[string]int64 + blockHash common.Hash + deletedNodeHashToBlockNumber map[common.Hash]int64 } type deathRow []*deathRecord @@ -77,8 +77,8 @@ type FullNode struct { deathList []deathRow storageDB chaindb.Database journalDB chaindb.Database - // deathIndex is the mapping from deleted node Merkle value to block number. - deathIndex map[string]int64 + // deathIndex is the mapping from deleted node hash to block number. + deathIndex map[common.Hash]int64 // pendingNumber is the block number to be pruned. // Initial value is set to 1 and is incremented after every block pruning. pendingNumber int64 @@ -89,10 +89,10 @@ type FullNode struct { type journalRecord struct { // blockHash of the block corresponding to journal record blockHash common.Hash - // Merkle values of nodes inserted in the state trie of the block - insertedMerkleValues map[string]struct{} - // Merkle values of nodes deleted from the state trie of the block - deletedMerkleValues map[string]struct{} + // Node hashes of nodes inserted in the state trie of the block + insertedNodeHashes map[common.Hash]struct{} + // Node hashes of nodes deleted from the state trie of the block + deletedNodeHashes map[common.Hash]struct{} } type journalKey struct { @@ -100,12 +100,12 @@ type journalKey struct { blockHash common.Hash } -func newJournalRecord(hash common.Hash, insertedMerkleValues, - deletedMerkleValues map[string]struct{}) *journalRecord { +func newJournalRecord(hash common.Hash, insertedNodeHashes, + deletedNodeHashes map[common.Hash]struct{}) *journalRecord { return &journalRecord{ - blockHash: hash, - insertedMerkleValues: insertedMerkleValues, - deletedMerkleValues: deletedMerkleValues, + blockHash: hash, + insertedNodeHashes: insertedNodeHashes, + deletedNodeHashes: deletedNodeHashes, } } @@ -113,7 +113,7 @@ func newJournalRecord(hash common.Hash, insertedMerkleValues, func NewFullNode(db, storageDB chaindb.Database, retainBlocks uint32, l log.LeveledLogger) (Pruner, error) { p := &FullNode{ deathList: make([]deathRow, 0), - deathIndex: make(map[string]int64), + deathIndex: make(map[common.Hash]int64), storageDB: storageDB, journalDB: chaindb.NewTable(db, journalPrefix), retainBlocks: retainBlocks, @@ -141,9 +141,9 @@ func NewFullNode(db, storageDB chaindb.Database, retainBlocks uint32, l log.Leve } // StoreJournalRecord stores journal record into DB and add deathRow into deathList -func (p *FullNode) StoreJournalRecord(deletedMerkleValues, insertedMerkleValues map[string]struct{}, +func (p *FullNode) StoreJournalRecord(deletedNodeHashes, insertedNodeHashes map[common.Hash]struct{}, blockHash common.Hash, blockNum int64) error { - jr := newJournalRecord(blockHash, insertedMerkleValues, deletedMerkleValues) + jr := newJournalRecord(blockHash, insertedNodeHashes, deletedNodeHashes) key := &journalKey{blockNum, blockHash} err := p.storeJournal(key, jr) @@ -169,13 +169,13 @@ func (p *FullNode) addDeathRow(jr *journalRecord, blockNum int64) { return } - p.processInsertedKeys(jr.insertedMerkleValues, jr.blockHash) + p.processInsertedKeys(jr.insertedNodeHashes, jr.blockHash) - // add deleted node Merkle values from journal to death index - deletedMerkleValueToBlockNumber := make(map[string]int64, len(jr.deletedMerkleValues)) - for k := range jr.deletedMerkleValues { + // add deleted node hashes from journal to death index + deletedNodeHashToBlockNumber := make(map[common.Hash]int64, len(jr.deletedNodeHashes)) + for k := range jr.deletedNodeHashes { p.deathIndex[k] = blockNum - deletedMerkleValueToBlockNumber[k] = blockNum + deletedNodeHashToBlockNumber[k] = blockNum } blockIndex := blockNum - p.pendingNumber @@ -184,8 +184,8 @@ func (p *FullNode) addDeathRow(jr *journalRecord, blockNum int64) { } record := &deathRecord{ - blockHash: jr.blockHash, - deletedMerkleValueToBlockNumber: deletedMerkleValueToBlockNumber, + blockHash: jr.blockHash, + deletedNodeHashToBlockNumber: deletedNodeHashToBlockNumber, } // add deathRow to deathList @@ -193,8 +193,8 @@ func (p *FullNode) addDeathRow(jr *journalRecord, blockNum int64) { } // Remove re-inserted keys -func (p *FullNode) processInsertedKeys(insertedMerkleValues map[string]struct{}, blockHash common.Hash) { - for k := range insertedMerkleValues { +func (p *FullNode) processInsertedKeys(insertedNodeHashes map[common.Hash]struct{}, blockHash common.Hash) { + for k := range insertedNodeHashes { num, ok := p.deathIndex[k] if !ok { continue @@ -202,7 +202,7 @@ func (p *FullNode) processInsertedKeys(insertedMerkleValues map[string]struct{}, records := p.deathList[num-p.pendingNumber] for _, v := range records { if v.blockHash == blockHash { - delete(v.deletedMerkleValueToBlockNumber, k) + delete(v.deletedNodeHashToBlockNumber, k) } } delete(p.deathIndex, k) @@ -230,14 +230,14 @@ func (p *FullNode) start() { sdbBatch := p.storageDB.NewBatch() for _, record := range row { - err := p.deleteKeys(sdbBatch, record.deletedMerkleValueToBlockNumber) + err := p.deleteKeys(sdbBatch, record.deletedNodeHashToBlockNumber) if err != nil { p.logger.Warnf("failed to prune keys for block number %d: %s", blockNum, err) sdbBatch.Reset() return } - for k := range record.deletedMerkleValueToBlockNumber { + for k := range record.deletedNodeHashToBlockNumber { delete(p.deathIndex, k) } } @@ -374,9 +374,9 @@ func (p *FullNode) getLastPrunedIndex() (int64, error) { return blockNum, nil } -func (*FullNode) deleteKeys(b chaindb.Batch, deletedMerkleValueToBlockNumber map[string]int64) error { - for merkleValue := range deletedMerkleValueToBlockNumber { - err := b.Del([]byte(merkleValue)) +func (*FullNode) deleteKeys(b chaindb.Batch, deletedNodeHashToBlockNumber map[common.Hash]int64) error { + for nodeHash := range deletedNodeHashToBlockNumber { + err := b.Del(nodeHash.ToBytes()) if err != nil { return err } diff --git a/dot/state/storage.go b/dot/state/storage.go index b2ba64870ee..8933e806dcb 100644 --- a/dot/state/storage.go +++ b/dot/state/storage.go @@ -85,13 +85,13 @@ func (s *StorageState) StoreTrie(ts *rtstorage.TrieState, header *types.Header) } if header != nil { - insertedMerkleValues, err := ts.GetInsertedMerkleValues() + insertedNodeHashes, err := ts.GetInsertedNodeHashes() if err != nil { - return fmt.Errorf("failed to get state trie inserted keys: block %s %w", header.Hash(), err) + return fmt.Errorf("getting trie inserted node hashes for block hash %s: %w", header.Hash(), err) } - deletedMerkleValues := ts.GetDeletedMerkleValues() - err = s.pruner.StoreJournalRecord(deletedMerkleValues, insertedMerkleValues, header.Hash(), int64(header.Number)) + deletedNodeHashes := ts.GetDeletedNodeHashes() + err = s.pruner.StoreJournalRecord(deletedNodeHashes, insertedNodeHashes, header.Hash(), int64(header.Number)) if err != nil { return err } diff --git a/lib/runtime/storage/trie.go b/lib/runtime/storage/trie.go index c3dd7e413d8..bdc624378af 100644 --- a/lib/runtime/storage/trie.go +++ b/lib/runtime/storage/trie.go @@ -291,18 +291,18 @@ func (s *TrieState) LoadCodeHash() (common.Hash, error) { return common.Blake2bHash(code) } -// GetInsertedMerkleValues returns the set of all node Merkle value inserted +// GetInsertedNodeHashes returns the set of all node hashes inserted // into the state trie since the last block produced. -func (s *TrieState) GetInsertedMerkleValues() (merkleValues map[string]struct{}, err error) { +func (s *TrieState) GetInsertedNodeHashes() (nodeHashes map[common.Hash]struct{}, err error) { s.lock.RLock() defer s.lock.RUnlock() - return s.t.GetInsertedMerkleValues() + return s.t.GetInsertedNodeHashes() } -// GetDeletedMerkleValues returns the set of all node Merkle values deleted +// GetDeletedNodeHashes returns the set of all node hashes deleted // from the state trie since the last block produced. -func (s *TrieState) GetDeletedMerkleValues() (merkleValues map[string]struct{}) { +func (s *TrieState) GetDeletedNodeHashes() (nodeHashes map[common.Hash]struct{}) { s.lock.RLock() defer s.lock.RUnlock() - return s.t.GetDeletedMerkleValues() + return s.t.GetDeletedNodeHashes() } diff --git a/lib/trie/database.go b/lib/trie/database.go index 1fbfa6c8530..4a5a17a9910 100644 --- a/lib/trie/database.go +++ b/lib/trie/database.go @@ -122,9 +122,9 @@ func (t *Trie) loadNode(db Database, n *Node) error { merkleValue := child.MerkleValue - if len(merkleValue) == 0 { + if len(merkleValue) < 32 { // node has already been loaded inline - // just set encoding + hash digest + // just set its encoding _, err := child.CalculateMerkleValue() if err != nil { return fmt.Errorf("merkle value: %w", err) @@ -133,25 +133,26 @@ func (t *Trie) loadNode(db Database, n *Node) error { continue } - encodedNode, err := db.Get(merkleValue) + nodeHash := merkleValue + encodedNode, err := db.Get(nodeHash) if err != nil { - return fmt.Errorf("cannot find child node key 0x%x in database: %w", merkleValue, err) + return fmt.Errorf("cannot find child node key 0x%x in database: %w", nodeHash, err) } reader := bytes.NewReader(encodedNode) decodedNode, err := node.Decode(reader) if err != nil { - return fmt.Errorf("decoding node with Merkle value 0x%x: %w", merkleValue, err) + return fmt.Errorf("decoding node with hash 0x%x: %w", nodeHash, err) } decodedNode.SetClean() decodedNode.Encoding = encodedNode - decodedNode.MerkleValue = merkleValue + decodedNode.MerkleValue = nodeHash branch.Children[i] = decodedNode err = t.loadNode(db, decodedNode) if err != nil { - return fmt.Errorf("loading child at index %d with Merkle value 0x%x: %w", i, merkleValue, err) + return fmt.Errorf("loading child at index %d with node hash 0x%x: %w", i, nodeHash, err) } if decodedNode.Kind() == node.Branch { @@ -189,7 +190,7 @@ func (t *Trie) loadNode(db Database, n *Node) error { // all its descendant nodes as keys to the nodeHashes map. // It is assumed the node and its descendant nodes have their Merkle value already // computed. -func PopulateNodeHashes(n *Node, nodeHashes map[string]struct{}) { +func PopulateNodeHashes(n *Node, nodeHashes map[common.Hash]struct{}) { if n == nil { return } @@ -205,7 +206,8 @@ func PopulateNodeHashes(n *Node, nodeHashes map[string]struct{}) { return } - nodeHashes[string(n.MerkleValue)] = struct{}{} + nodeHash := common.NewHash(n.MerkleValue) + nodeHashes[nodeHash] = struct{}{} if n.Kind() == node.Leaf { return @@ -362,11 +364,18 @@ func (t *Trie) writeDirtyNode(db chaindb.Batch, n *Node) (err error) { n.MerkleValue, err) } - err = db.Put(merkleValue, encoding) + if len(merkleValue) < 32 { + // Inlined node, there is no need to write it to database. + return nil + } + + nodeHash := merkleValue + + err = db.Put(nodeHash, encoding) if err != nil { return fmt.Errorf( - "putting encoding of node with Merkle value 0x%x in database: %w", - merkleValue, err) + "putting encoding of node with node hash 0x%x in database: %w", + nodeHash, err) } if n.Kind() != node.Branch { @@ -397,18 +406,18 @@ func (t *Trie) writeDirtyNode(db chaindb.Batch, n *Node) (err error) { return nil } -// GetInsertedMerkleValues returns the set of node Merkle values +// GetInsertedNodeHashes returns the set of node Merkle values // for each node that was inserted in the state trie since the last snapshot. -func (t *Trie) GetInsertedMerkleValues() (merkleValues map[string]struct{}, err error) { - merkleValues = make(map[string]struct{}) - err = t.getInsertedNodeHashesAtNode(t.root, merkleValues) +func (t *Trie) GetInsertedNodeHashes() (nodeHashes map[common.Hash]struct{}, err error) { + nodeHashes = make(map[common.Hash]struct{}) + err = t.getInsertedNodeHashesAtNode(t.root, nodeHashes) if err != nil { return nil, err } - return merkleValues, nil + return nodeHashes, nil } -func (t *Trie) getInsertedNodeHashesAtNode(n *Node, merkleValues map[string]struct{}) (err error) { +func (t *Trie) getInsertedNodeHashesAtNode(n *Node, nodeHashes map[common.Hash]struct{}) (err error) { if n == nil || !n.Dirty { return nil } @@ -425,7 +434,16 @@ func (t *Trie) getInsertedNodeHashesAtNode(n *Node, merkleValues map[string]stru n.MerkleValue, err) } - merkleValues[string(merkleValue)] = struct{}{} + if len(merkleValue) < 32 { + // this is an inlined node and is encoded as part of its parent node. + // Therefore it is not written to disk and the online pruner does not + // need to track it. If the node encodes to less than 32B, it cannot have + // non-inlined children so it's safe to stop here and not recurse further. + return nil + } + + nodeHash := common.NewHash(merkleValue) + nodeHashes[nodeHash] = struct{}{} if n.Kind() != node.Branch { return nil @@ -436,7 +454,7 @@ func (t *Trie) getInsertedNodeHashesAtNode(n *Node, merkleValues map[string]stru continue } - err := t.getInsertedNodeHashesAtNode(child, merkleValues) + err := t.getInsertedNodeHashesAtNode(child, nodeHashes) if err != nil { // Note: do not wrap error since this is called recursively. return err @@ -446,15 +464,9 @@ func (t *Trie) getInsertedNodeHashesAtNode(n *Node, merkleValues map[string]stru return nil } -// GetDeletedMerkleValues returns a set of all the node Merkle values for each -// node that was deleted from the trie since the last snapshot was made. -// The returned set is a copy of the internal set to prevent data corruption. -func (t *Trie) GetDeletedMerkleValues() (merkleValues map[string]struct{}) { - deletedNodeHashes := t.deltas.Deleted() - // TODO return deletedNodeHashes directly after changing MerkleValue -> NodeHash - merkleValues = make(map[string]struct{}, len(deletedNodeHashes)) - for nodeHash := range deletedNodeHashes { - merkleValues[string(nodeHash[:])] = struct{}{} - } - return merkleValues +// GetDeletedNodeHashes returns a set of all the node hashes for each +// node (with a scale encoding larger than 32B) that was deleted from +// the trie since the last snapshot was made. +func (t *Trie) GetDeletedNodeHashes() (nodeHashes map[common.Hash]struct{}) { + return t.deltas.Deleted() } diff --git a/lib/trie/database_test.go b/lib/trie/database_test.go index 341eaa2e885..02e9d1dd9e4 100644 --- a/lib/trie/database_test.go +++ b/lib/trie/database_test.go @@ -7,6 +7,7 @@ import ( "testing" "github.com/ChainSafe/chaindb" + "github.com/ChainSafe/gossamer/lib/common" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -161,28 +162,34 @@ func Test_Trie_WriteDirty_ClearPrefix(t *testing.T) { func Test_PopulateNodeHashes(t *testing.T) { t.Parallel() - const ( - merkleValue32Zeroes = "00000000000000000000000000000000" - merkleValue32Ones = "11111111111111111111111111111111" - merkleValue32Twos = "22222222222222222222222222222222" - merkleValue32Threes = "33333333333333333333333333333333" + var ( + merkleValue32Zeroes = common.Hash{} + merkleValue32Ones = common.Hash{ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} + merkleValue32Twos = common.Hash{ + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2} + merkleValue32Threes = common.Hash{ + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3} ) testCases := map[string]struct { node *Node - nodeHashes map[string]struct{} + nodeHashes map[common.Hash]struct{} panicValue interface{} }{ "nil node": { - nodeHashes: map[string]struct{}{}, + nodeHashes: map[common.Hash]struct{}{}, }, "inlined leaf node": { node: &Node{MerkleValue: []byte("a")}, - nodeHashes: map[string]struct{}{}, + nodeHashes: map[common.Hash]struct{}{}, }, "leaf node": { - node: &Node{MerkleValue: []byte(merkleValue32Zeroes)}, - nodeHashes: map[string]struct{}{ + node: &Node{MerkleValue: merkleValue32Zeroes.ToBytes()}, + nodeHashes: map[common.Hash]struct{}{ merkleValue32Zeroes: {}, }, }, @@ -197,34 +204,34 @@ func Test_PopulateNodeHashes(t *testing.T) { {MerkleValue: []byte("b")}, }), }, - nodeHashes: map[string]struct{}{}, + nodeHashes: map[common.Hash]struct{}{}, }, "branch node": { node: &Node{ - MerkleValue: []byte(merkleValue32Zeroes), + MerkleValue: merkleValue32Zeroes.ToBytes(), Children: padRightChildren([]*Node{ - {MerkleValue: []byte(merkleValue32Ones)}, + {MerkleValue: merkleValue32Ones.ToBytes()}, }), }, - nodeHashes: map[string]struct{}{ + nodeHashes: map[common.Hash]struct{}{ merkleValue32Zeroes: {}, merkleValue32Ones: {}, }, }, "nested branch node": { node: &Node{ - MerkleValue: []byte(merkleValue32Zeroes), + MerkleValue: merkleValue32Zeroes.ToBytes(), Children: padRightChildren([]*Node{ - {MerkleValue: []byte(merkleValue32Ones)}, + {MerkleValue: merkleValue32Ones.ToBytes()}, { - MerkleValue: []byte(merkleValue32Twos), + MerkleValue: merkleValue32Twos.ToBytes(), Children: padRightChildren([]*Node{ - {MerkleValue: []byte(merkleValue32Threes)}, + {MerkleValue: merkleValue32Threes.ToBytes()}, }), }, }), }, - nodeHashes: map[string]struct{}{ + nodeHashes: map[common.Hash]struct{}{ merkleValue32Zeroes: {}, merkleValue32Ones: {}, merkleValue32Twos: {}, @@ -238,7 +245,7 @@ func Test_PopulateNodeHashes(t *testing.T) { t.Run(name, func(t *testing.T) { t.Parallel() - nodeHashes := make(map[string]struct{}) + nodeHashes := make(map[common.Hash]struct{}) if testCase.panicValue != nil { assert.PanicsWithValue(t, testCase.panicValue, func() { diff --git a/lib/trie/proof/generate.go b/lib/trie/proof/generate.go index eb8075de9d9..0ac1c1d8c39 100644 --- a/lib/trie/proof/generate.go +++ b/lib/trie/proof/generate.go @@ -40,7 +40,7 @@ func Generate(rootHash []byte, fullKeys [][]byte, database Database) ( buffer := pools.DigestBuffers.Get().(*bytes.Buffer) defer pools.DigestBuffers.Put(buffer) - merkleValuesSeen := make(map[string]struct{}) + nodeHashesSeen := make(map[common.Hash]struct{}) for _, fullKey := range fullKeys { fullKeyNibbles := codec.KeyLEToNibbles(fullKey) newEncodedProofNodes, err := walkRoot(rootNode, fullKeyNibbles) @@ -56,13 +56,16 @@ func Generate(rootHash []byte, fullKeys [][]byte, database Database) ( if err != nil { return nil, fmt.Errorf("blake2b hash: %w", err) } - merkleValueString := buffer.String() + // Note: all encoded proof nodes are larger than 32B so their + // merkle value is the encoding hash digest (32B) and never the + // encoding itself. + nodeHash := common.NewHash(buffer.Bytes()) - _, seen := merkleValuesSeen[merkleValueString] + _, seen := nodeHashesSeen[nodeHash] if seen { continue } - merkleValuesSeen[merkleValueString] = struct{}{} + nodeHashesSeen[nodeHash] = struct{}{} encodedProofNodes = append(encodedProofNodes, encodedProofNode) } diff --git a/lib/trie/trie.go b/lib/trie/trie.go index 9c2f955ebe1..9536b62899f 100644 --- a/lib/trie/trie.go +++ b/lib/trie/trie.go @@ -91,7 +91,7 @@ func (t *Trie) prepForMutation(currentNode *Node, // update the node generation. newNode = currentNode } else { - err = t.registerDeletedMerkleValue(currentNode, pendingDeltas) + err = t.registerDeletedNodeHash(currentNode, pendingDeltas) if err != nil { return nil, fmt.Errorf("registering deleted node: %w", err) } @@ -102,7 +102,7 @@ func (t *Trie) prepForMutation(currentNode *Node, return newNode, nil } -func (t *Trie) registerDeletedMerkleValue(node *Node, +func (t *Trie) registerDeletedNodeHash(node *Node, pendingDeltas DeltaRecorder) (err error) { isRoot := node == t.root err = ensureMerkleValueIsCalculated(node, isRoot) @@ -809,7 +809,7 @@ func (t *Trie) clearPrefixLimitAtNode(parent *Node, prefix []byte, // TODO check this is the same behaviour as in substrate const allDeleted = true if bytes.HasPrefix(parent.Key, prefix) { - err = t.registerDeletedMerkleValue(parent, pendingDeltas) + err = t.registerDeletedNodeHash(parent, pendingDeltas) if err != nil { return nil, 0, 0, false, fmt.Errorf("registering deleted Merkle value: %w", err) @@ -950,7 +950,7 @@ func (t *Trie) deleteNodesLimit(parent *Node, limit uint32, } if parent.Kind() == node.Leaf { - err = t.registerDeletedMerkleValue(parent, pendingDeltas) + err = t.registerDeletedNodeHash(parent, pendingDeltas) if err != nil { return nil, 0, 0, fmt.Errorf("registering deleted merkle value: %w", err) } @@ -1100,7 +1100,7 @@ func (t *Trie) clearPrefixAtNode(parent *Node, prefix []byte, return nil, 0, fmt.Errorf("preparing branch for mutation: %w", err) } - err = t.registerDeletedMerkleValue(child, pendingDeltas) + err = t.registerDeletedNodeHash(child, pendingDeltas) if err != nil { return nil, 0, fmt.Errorf("registering deleted merkle value for child: %w", err) } @@ -1217,7 +1217,7 @@ func (t *Trie) deleteLeaf(parent *Node, key []byte, newParent = nil - err = t.registerDeletedMerkleValue(parent, pendingDeltas) + err = t.registerDeletedNodeHash(parent, pendingDeltas) if err != nil { return nil, fmt.Errorf("registering deleted merkle value: %w", err) } @@ -1338,7 +1338,7 @@ func (t *Trie) handleDeletion(branch *Node, key []byte, const branchChildMerged = true childIndex := firstChildIndex child := branch.Children[firstChildIndex] - err = t.registerDeletedMerkleValue(child, pendingDeltas) + err = t.registerDeletedNodeHash(child, pendingDeltas) if err != nil { return nil, false, fmt.Errorf("registering deleted merkle value: %w", err) } @@ -1378,7 +1378,7 @@ func (t *Trie) handleDeletion(branch *Node, key []byte, } } -// ensureMerkleValueIsCalculated is used before calling PopulateMerkleValues +// ensureMerkleValueIsCalculated is used before calling PopulateNodeHashes // to ensure the parent node and all its descendant nodes have their Merkle // value computed and ready to be used. This has a close to zero performance // impact if the parent node Merkle value is already computed. diff --git a/lib/trie/trie_endtoend_test.go b/lib/trie/trie_endtoend_test.go index c2923b9bcdf..9cba957f789 100644 --- a/lib/trie/trie_endtoend_test.go +++ b/lib/trie/trie_endtoend_test.go @@ -315,9 +315,9 @@ func TestTrieDiff(t *testing.T) { newTrie.Put(test.key, test.value) } - deletedMerkleValues := newTrie.deltas.Deleted() - expectedDeletdMerkleValues := map[common.Hash]struct{}{ - // root branch Merkle value which was modified (by its descendants). + deletedNodeHashes := newTrie.deltas.Deleted() + expectedDeletedNodeHashes := map[common.Hash]struct{}{ + // root branch hash which was modified (by its descendants). // Other nodes result in an encoding of less than 32B so they are not // tracked since they are inlined in the branch. {0xa9, 0x76, 0xfa, 0x55, 0x6d, 0x65, 0x24, 0x3c, @@ -325,13 +325,13 @@ func TestTrieDiff(t *testing.T) { 0xe4, 0xb6, 0x8a, 0x60, 0xe5, 0x4d, 0xea, 0x68, 0x9c, 0xab, 0xbf, 0xbb, 0xc0, 0xfc, 0x72, 0x48}: {}, } - assert.Equal(t, expectedDeletdMerkleValues, deletedMerkleValues) + assert.Equal(t, expectedDeletedNodeHashes, deletedNodeHashes) err = newTrie.WriteDirty(storageDB) require.NoError(t, err) - for deletedMerkleValue := range deletedMerkleValues { - err = storageDB.Del(deletedMerkleValue[:]) + for deletedNodeHash := range deletedNodeHashes { + err = storageDB.Del(deletedNodeHash[:]) require.NoError(t, err) } diff --git a/lib/trie/trie_test.go b/lib/trie/trie_test.go index cafafdcc8d6..fff06d54d44 100644 --- a/lib/trie/trie_test.go +++ b/lib/trie/trie_test.go @@ -254,7 +254,7 @@ func Test_Trie_prepForMutation(t *testing.T) { } } -func Test_Trie_registerDeletedMerkleValue(t *testing.T) { +func Test_Trie_registerDeletedNodeHash(t *testing.T) { t.Parallel() someSmallNode := &Node{ @@ -317,7 +317,7 @@ func Test_Trie_registerDeletedMerkleValue(t *testing.T) { trie := testCase.trie - err := trie.registerDeletedMerkleValue(testCase.node, + err := trie.registerDeletedNodeHash(testCase.node, testCase.pendingDeltas) require.NoError(t, err)