trie: rework trie hasher

trie/hasher.go

@@ -17,6 +17,7 @@
 package trie
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/ethereum/go-ethereum/crypto"
@@ -54,7 +55,7 @@ func returnHasherToPool(h *hasher) {
 }
 
 // hash collapses a node down into a hash node.
-func (h *hasher) hash(n node, force bool) node {
+func (h *hasher) hash(n node, force bool) []byte {
 	// Return the cached hash if it's available
 	if hash, _ := n.cache(); hash != nil {
 		return hash
@@ -62,101 +63,86 @@ func (h *hasher) hash(n node, force bool) node {
 	// Trie not processed yet, walk the children
 	switch n := n.(type) {
 	case *shortNode:
-		collapsed := h.hashShortNodeChildren(n)
+		enc := h.encodeShortNode(n)
-		hashed := h.shortnodeToHash(collapsed, force)
+		if len(enc) < 32 && !force {
-		if hn, ok := hashed.(hashNode); ok {
+			buf := make([]byte, len(enc))
-			n.flags.hash = hn
+			copy(buf, enc)
-		} else {
+			return buf // Nodes smaller than 32 bytes are stored inside their parent
-			n.flags.hash = nil
 		}
-		return hashed
+		hash := h.hashData(enc)
+		n.flags.hash = hash
+		return hash
+
 	case *fullNode:
-		collapsed := h.hashFullNodeChildren(n)
+		enc := h.encodeFullNode(n)
-		hashed := h.fullnodeToHash(collapsed, force)
+		if len(enc) < 32 && !force {
-		if hn, ok := hashed.(hashNode); ok {
+			buf := make([]byte, len(enc))
-			n.flags.hash = hn
+			copy(buf, enc)
-		} else {
+			return buf // Nodes smaller than 32 bytes are stored inside their parent
-			n.flags.hash = nil
 		}
-		return hashed
+		hash := h.hashData(enc)
-	default:
+		n.flags.hash = hash
-		// Value and hash nodes don't have children, so they're left as were
+		return hash
+
+	case hashNode:
+		// hash nodes don't have children, so they're left as were
 		return n
-	}
-}
 
-// hashShortNodeChildren returns a copy of the supplied shortNode, with its child
-// being replaced by either the hash or an embedded node if the child is small.
-func (h *hasher) hashShortNodeChildren(n *shortNode) *shortNode {
-	var collapsed shortNode
-	collapsed.Key = hexToCompact(n.Key)
-	switch n.Val.(type) {
-	case *fullNode, *shortNode:
-		collapsed.Val = h.hash(n.Val, false)
 	default:
-		collapsed.Val = n.Val
+		panic(fmt.Errorf("unexpected node type, %T", n))
 	}
-	return &collapsed
 }
 
-// hashFullNodeChildren returns a copy of the supplied fullNode, with its child
+func (h *hasher) encodeShortNode(n *shortNode) []byte {
+	// Encode leaf node
+	if hasTerm(n.Key) {
+		var ln leafNodeEncoder
+		ln.Key = hexToCompact(n.Key)
+		ln.Val = n.Val.(valueNode)
+		ln.encode(h.encbuf)
+		return h.encodedBytes()
+	}
+	// Encode extension node
+	var en extNodeEncoder
+	en.Key = hexToCompact(n.Key)
+	en.Val = h.hash(n.Val, false)
+	en.encode(h.encbuf)
+	return h.encodedBytes()
+}
+
+// encodeFullNode returns a copy of the supplied fullNode, with its child
 // being replaced by either the hash or an embedded node if the child is small.
-func (h *hasher) hashFullNodeChildren(n *fullNode) *fullNode {
+func (h *hasher) encodeFullNode(n *fullNode) []byte {
-	var children [17]node
+	var fn fullnodeEncoder
 	if h.parallel {
 		var wg sync.WaitGroup
 		for i := 0; i < 16; i++ {
-			if child := n.Children[i]; child != nil {
+			if n.Children[i] == nil {
+				continue
+			}
 			wg.Add(1)
 			go func(i int) {
 				hasher := newHasher(false)
-					children[i] = hasher.hash(child, false)
+				if child := n.Children[i]; child != nil {
+					fn.Children[i] = hasher.hash(child, false)
+				}
 				returnHasherToPool(hasher)
 				wg.Done()
 			}(i)
-			} else {
-				children[i] = nilValueNode
-			}
 		}
 		wg.Wait()
 	} else {
 		for i := 0; i < 16; i++ {
 			if child := n.Children[i]; child != nil {
-				children[i] = h.hash(child, false)
+				fn.Children[i] = h.hash(child, false)
-			} else {
-				children[i] = nilValueNode
 			}
 		}
 	}
 	if n.Children[16] != nil {
-		children[16] = n.Children[16]
+		fn.Children[16] = n.Children[16].(valueNode)
 	}
-	return &fullNode{flags: nodeFlag{}, Children: children}
+	fn.encode(h.encbuf)
-}
+	return h.encodedBytes()
-
-// shortNodeToHash computes the hash of the given shortNode. The shortNode must
-// first be collapsed, with its key converted to compact form. If the RLP-encoded
-// node data is smaller than 32 bytes, the node itself is returned.
-func (h *hasher) shortnodeToHash(n *shortNode, force bool) node {
-	n.encode(h.encbuf)
-	enc := h.encodedBytes()
-
-	if len(enc) < 32 && !force {
-		return n // Nodes smaller than 32 bytes are stored inside their parent
-	}
-	return h.hashData(enc)
-}
-
-// fullnodeToHash computes the hash of the given fullNode. If the RLP-encoded
-// node data is smaller than 32 bytes, the node itself is returned.
-func (h *hasher) fullnodeToHash(n *fullNode, force bool) node {
-	n.encode(h.encbuf)
-	enc := h.encodedBytes()
-
-	if len(enc) < 32 && !force {
-		return n // Nodes smaller than 32 bytes are stored inside their parent
-	}
-	return h.hashData(enc)
 }
 
 // encodedBytes returns the result of the last encoding operation on h.encbuf.
@@ -176,8 +162,8 @@ func (h *hasher) encodedBytes() []byte {
 }
 
 // hashData hashes the provided data
-func (h *hasher) hashData(data []byte) hashNode {
+func (h *hasher) hashData(data []byte) []byte {
-	n := make(hashNode, 32)
+	n := make([]byte, 32)
 	h.sha.Reset()
 	h.sha.Write(data)
 	h.sha.Read(n)
@@ -196,16 +182,13 @@ func (h *hasher) hashDataTo(dst, data []byte) {
 // 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.
 // 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) []byte {
 	switch n := original.(type) {
 	case *shortNode:
-		sn := h.hashShortNodeChildren(n)
+		return h.encodeShortNode(n)
-		return sn, h.shortnodeToHash(sn, false)
 	case *fullNode:
-		fn := h.hashFullNodeChildren(n)
+		return h.encodeFullNode(n)
-		return fn, h.fullnodeToHash(fn, false)
 	default:
-		// Value and hash nodes don't have children, so they're left as were
+		panic(fmt.Errorf("unexpected node type, %T", original))
-		return n, n
 	}
 }

trie/iterator.go

@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"container/heap"
 	"errors"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 )
@@ -240,9 +239,9 @@ func (it *nodeIterator) LeafProof() [][]byte {
 
 			for i, item := range it.stack[:len(it.stack)-1] {
 				// Gather nodes that end up as hash nodes (or the root)
-				node, hashed := hasher.proofHash(item.node)
+				enc := hasher.proofHash(item.node)
-				if _, ok := hashed.(hashNode); ok || i == 0 {
+				if len(enc) >= 32 || i == 0 {
-					proofs = append(proofs, nodeToBytes(node))
+					proofs = append(proofs, common.CopyBytes(enc))
 				}
 			}
 			return proofs

trie/node.go

@@ -68,10 +68,6 @@ type (
 	}
 )
 
-// nilValueNode is used when collapsing internal trie nodes for hashing, since
-// unset children need to serialize correctly.
-var nilValueNode = valueNode(nil)
-
 // EncodeRLP encodes a full node into the consensus RLP format.
 func (n *fullNode) EncodeRLP(w io.Writer) error {
 	eb := rlp.NewEncoderBuffer(w)

trie/node_enc.go

@@ -42,15 +42,21 @@ func (n *fullNode) encode(w rlp.EncoderBuffer) {
 
 func (n *fullnodeEncoder) encode(w rlp.EncoderBuffer) {
 	offset := w.List()
-	for _, c := range n.Children {
+	for i, c := range n.Children {
 		if c == nil {
 			w.Write(rlp.EmptyString)
-		} else if len(c) < 32 {
+		} else {
+			if i == 16 {
+				w.WriteBytes(c) // valueNode
+			} else {
+				if len(c) < 32 {
 					w.Write(c) // rawNode
 				} else {
 					w.WriteBytes(c) // hashNode
 				}
 			}
+		}
+	}
 	w.ListEnd(offset)
 }
 

trie/proof.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -85,16 +86,12 @@ func (t *Trie) Prove(key []byte, proofDb ethdb.KeyValueWriter) error {
 	defer returnHasherToPool(hasher)
 
 	for i, n := range nodes {
-		var hn node
+		enc := hasher.proofHash(n)
-		n, hn = hasher.proofHash(n)
+		if len(enc) == 32 {
-		if hash, ok := hn.(hashNode); ok || i == 0 {
+			fmt.Println("DEBUG")
-			// If the node's database encoding is a hash (or is the
-			// root node), it becomes a proof element.
-			enc := nodeToBytes(n)
-			if !ok {
-				hash = hasher.hashData(enc)
 		}
-			proofDb.Put(hash, enc)
+		if len(enc) >= 32 || i == 0 {
+			proofDb.Put(crypto.Keccak256(enc), enc)
 		}
 	}
 	return nil

trie/trie.go

@@ -626,7 +626,7 @@ func (t *Trie) resolveAndTrack(n hashNode, prefix []byte) (node, error) {
 // Hash returns the root hash of the trie. It does not write to the
 // database and can be used even if the trie doesn't have one.
 func (t *Trie) Hash() common.Hash {
-	return common.BytesToHash(t.hashRoot().(hashNode))
+	return common.BytesToHash(t.hashRoot())
 }
 
 // Commit collects all dirty nodes in the trie and replaces them with the
@@ -677,9 +677,9 @@ func (t *Trie) Commit(collectLeaf bool) (common.Hash, *trienode.NodeSet) {
 }
 
 // hashRoot calculates the root hash of the given trie
-func (t *Trie) hashRoot() node {
+func (t *Trie) hashRoot() []byte {
 	if t.root == nil {
-		return hashNode(types.EmptyRootHash.Bytes())
+		return types.EmptyRootHash.Bytes()
 	}
 	// If the number of changes is below 100, we let one thread handle it
 	h := newHasher(t.unhashed >= 100)

trie/trie_test.go

@@ -863,7 +863,7 @@ func (s *spongeDb) Flush() {
 		s.sponge.Write([]byte(key))
 		s.sponge.Write([]byte(s.values[key]))
 	}
-	fmt.Println(len(s.keys))
+	//fmt.Println(len(s.keys))
 }
 
 // spongeBatch is a dummy batch which immediately writes to the underlying spongedb