chore(trie): add MerkleValue method and functions

internal/trie/node/branch_encode.go

@@ -6,7 +6,6 @@ package node
 import (
 	"bytes"
 	"fmt"
-	"hash"
 	"io"
 	"runtime"
 
@@ -147,56 +146,15 @@ func encodeChild(child *Node, buffer io.Writer) (err error) {
 // and then SCALE encodes it. This is used to encode children
 // nodes of branches.
 func scaleEncodeHash(node *Node) (encoding []byte, err error) {
-	buffer := pools.DigestBuffers.Get().(*bytes.Buffer)
-	buffer.Reset()
-	defer pools.DigestBuffers.Put(buffer)
-
-	err = hashNode(node, buffer)
+	_, merkleValue, err := node.EncodeAndHash()
 	if err != nil {
-		return nil, fmt.Errorf("cannot hash %s: %w", node.Kind(), err)
+		return nil, fmt.Errorf("encoding and hashing %s: %w", node.Kind(), err)
 	}
 
-	encoding, err = scale.Marshal(buffer.Bytes())
+	encoding, err = scale.Marshal(merkleValue)
 	if err != nil {
 		return nil, fmt.Errorf("cannot scale encode hashed %s: %w", node.Kind(), err)
 	}
 
 	return encoding, nil
 }
-
-func hashNode(node *Node, digestWriter io.Writer) (err error) {
-	encodingBuffer := pools.EncodingBuffers.Get().(*bytes.Buffer)
-	encodingBuffer.Reset()
-	defer pools.EncodingBuffers.Put(encodingBuffer)
-
-	err = node.Encode(encodingBuffer)
-	if err != nil {
-		return fmt.Errorf("cannot encode %s: %w", node.Kind(), err)
-	}
-
-	// if length of encoded leaf is less than 32 bytes, do not hash
-	if encodingBuffer.Len() < 32 {
-		_, err = digestWriter.Write(encodingBuffer.Bytes())
-		if err != nil {
-			return fmt.Errorf("cannot write encoded %s to buffer: %w", node.Kind(), err)
-		}
-		return nil
-	}
-
-	// otherwise, hash encoded node
-	hasher := pools.Hashers.Get().(hash.Hash)
-	hasher.Reset()
-	defer pools.Hashers.Put(hasher)
-
-	// Note: using the sync.Pool's buffer is useful here.
-	_, err = hasher.Write(encodingBuffer.Bytes())
-	if err != nil {
-		return fmt.Errorf("cannot hash encoding of %s: %w", node.Kind(), err)
-	}
-
-	_, err = digestWriter.Write(hasher.Sum(nil))
-	if err != nil {
-		return fmt.Errorf("cannot write hash sum of %s to buffer: %w", node.Kind(), err)
-	}
-	return nil
-}

internal/trie/node/branch_encode_test.go

@@ -13,159 +13,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func Test_hashNode(t *testing.T) {
-	t.Parallel()
-
-	testCases := map[string]struct {
-		node       *Node
-		write      writeCall
-		errWrapped error
-		errMessage string
-	}{
-		"small leaf buffer write error": {
-			node: &Node{
-				Encoding: []byte{1, 2, 3},
-			},
-			write: writeCall{
-				written: []byte{1, 2, 3},
-				err:     errTest,
-			},
-			errWrapped: errTest,
-			errMessage: "cannot write encoded leaf to buffer: " +
-				"test error",
-		},
-		"small leaf success": {
-			node: &Node{
-				Encoding: []byte{1, 2, 3},
-			},
-			write: writeCall{
-				written: []byte{1, 2, 3},
-			},
-		},
-		"leaf hash sum buffer write error": {
-			node: &Node{
-				Encoding: []byte{
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-				},
-			},
-			write: writeCall{
-				written: []byte{
-					107, 105, 154, 175, 253, 170, 232,
-					135, 240, 21, 207, 148, 82, 117,
-					249, 230, 80, 197, 254, 17, 149,
-					108, 50, 7, 80, 56, 114, 176,
-					84, 114, 125, 234},
-				err: errTest,
-			},
-			errWrapped: errTest,
-			errMessage: "cannot write hash sum of leaf to buffer: " +
-				"test error",
-		},
-		"leaf hash sum success": {
-			node: &Node{
-				Encoding: []byte{
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-					1, 2, 3, 4, 5, 6, 7, 8,
-				},
-			},
-			write: writeCall{
-				written: []byte{
-					107, 105, 154, 175, 253, 170, 232,
-					135, 240, 21, 207, 148, 82, 117,
-					249, 230, 80, 197, 254, 17, 149,
-					108, 50, 7, 80, 56, 114, 176,
-					84, 114, 125, 234},
-			},
-		},
-		"empty branch": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-			},
-			write: writeCall{
-				written: []byte{128, 0, 0},
-			},
-		},
-		"less than 32 bytes encoding": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Key:      []byte{1, 2},
-			},
-			write: writeCall{
-				written: []byte{130, 18, 0, 0},
-			},
-		},
-		"less than 32 bytes encoding write error": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Key:      []byte{1, 2},
-			},
-			write: writeCall{
-				written: []byte{130, 18, 0, 0},
-				err:     errTest,
-			},
-			errWrapped: errTest,
-			errMessage: "cannot write encoded branch to buffer: test error",
-		},
-		"more than 32 bytes encoding": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Key:      repeatBytes(100, 1),
-			},
-			write: writeCall{
-				written: []byte{
-					70, 102, 188, 24, 31, 68, 86, 114,
-					95, 156, 225, 138, 175, 254, 176, 251,
-					81, 84, 193, 40, 11, 234, 142, 233,
-					69, 250, 158, 86, 72, 228, 66, 46},
-			},
-		},
-		"more than 32 bytes encoding write error": {
-			node: &Node{
-				Children: make([]*Node, ChildrenCapacity),
-				Key:      repeatBytes(100, 1),
-			},
-			write: writeCall{
-				written: []byte{
-					70, 102, 188, 24, 31, 68, 86, 114,
-					95, 156, 225, 138, 175, 254, 176, 251,
-					81, 84, 193, 40, 11, 234, 142, 233,
-					69, 250, 158, 86, 72, 228, 66, 46},
-				err: errTest,
-			},
-			errWrapped: errTest,
-			errMessage: "cannot write hash sum of branch to buffer: test error",
-		},
-	}
-
-	for name, testCase := range testCases {
-		testCase := testCase
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-			ctrl := gomock.NewController(t)
-
-			digestBuffer := NewMockWriter(ctrl)
-			digestBuffer.EXPECT().Write(testCase.write.written).
-				Return(testCase.write.n, testCase.write.err)
-
-			err := hashNode(testCase.node, digestBuffer)
-
-			if testCase.errWrapped != nil {
-				assert.ErrorIs(t, err, testCase.errWrapped)
-				assert.EqualError(t, err, testCase.errMessage)
-			} else {
-				require.NoError(t, err)
-			}
-		})
-	}
-}
-
 // Opportunistic parallel:	13781602 ns/op	14419488 B/op	  323575 allocs/op
 // Sequentially:			24269268 ns/op	20126525 B/op	  327668 allocs/op
 func Benchmark_encodeChildrenOpportunisticParallel(b *testing.B) {