Update to Go 1.20 (#40)

Author: fasmat

.github/workflows/ci.yml

@@ -1,8 +1,5 @@
 name: CI
 
-env:
-  go-version: "1.19"
-
 # Controls when the action will run. Triggers the workflow on push or pull request
 # events but only for the develop branch
 on:
@@ -25,7 +22,8 @@ jobs:
       - name: set up go
         uses: actions/setup-go@v4
         with:
-          go-version: ${{ env.go-version }}
+          check-latest: true
+          go-version-file: "go.mod"
 
       - name: build
         run: go build -v ./...

cache/cache_test.go

@@ -28,8 +28,7 @@ func TestCache_ValidateStructure(t *testing.T) {
 	treeCache := &cache{layers: readers}
 	err := treeCache.validateStructure()
 
-	r.Error(err)
-	r.Equal("reader for base layer must be included", err.Error())
+	r.Error(err,"reader for base layer must be included")
 }
 
 func TestCache_ValidateStructure2(t *testing.T) {
@@ -39,8 +38,7 @@ func TestCache_ValidateStructure2(t *testing.T) {
 	treeCache := &cache{layers: readers}
 	err := treeCache.validateStructure()
 
-	r.Error(err)
-	r.Equal("reader for base layer must be included", err.Error())
+	r.Error(err,"reader for base layer must be included")
 }
 
 func TestCache_ValidateStructureSuccess(t *testing.T) {
@@ -66,8 +64,7 @@ func TestCache_ValidateStructureFail(t *testing.T) {
 	treeCache := &cache{layers: readers}
 	err := treeCache.validateStructure()
 
-	r.Error(err)
-	r.Equal("reader at layer 1 has width 2 instead of 1", err.Error())
+	r.Error(err,"reader at layer 1 has width 2 instead of 1")
 }
 
 func TestCache_ValidateStructureFail2(t *testing.T) {
@@ -80,6 +77,5 @@ func TestCache_ValidateStructureFail2(t *testing.T) {
 	treeCache := &cache{layers: readers}
 	err := treeCache.validateStructure()
 
-	r.Error(err)
-	r.Equal("reader at layer 1 has width 1 instead of 2", err.Error())
+	r.Error(err,"reader at layer 1 has width 1 instead of 2")
 }

go.mod

@@ -1,6 +1,6 @@
 module github.com/spacemeshos/merkle-tree
 
-go 1.19
+go 1.20
 
 require (
 	github.com/minio/sha256-simd v1.0.1

merkle.go

@@ -1,7 +1,7 @@
 package merkle
 
 import (
-	"errors"
+	"fmt"
 
 	"github.com/minio/sha256-simd"
 
@@ -117,7 +117,7 @@ func (t *Tree) AddLeaf(value []byte) error {
 		if l.cache != nil {
 			_, err := l.cache.Append(n.value)
 			if err != nil {
-				lastCachingError = errors.New("error while caching: " + err.Error())
+				lastCachingError = fmt.Errorf("error while caching: %w", err)
 			}
 		}
 

proving.go

@@ -84,12 +84,12 @@ func calcSubtreeProof(c CacheReader, leavesToProve Set, subtreeStart Position, w
 	reader := c.GetLayerReader(0)
 	err = reader.Seek(subtreeStart.Index)
 	if err != nil {
-		return nil, nil, errors.New("while preparing to traverse subtree: " + err.Error())
+		return nil, nil, fmt.Errorf("while preparing to traverse subtree: %w", err)
 	}
 
 	_, additionalProof, additionalLeaves, err = traverseSubtree(reader, width, c.GetHashFunc(), relativeLeavesToProve, nil)
 	if err != nil {
-		return nil, nil, errors.New("while traversing subtree: " + err.Error())
+		return nil, nil, fmt.Errorf("while traversing subtree: %w", err)
 	}
 
 	return additionalProof, additionalLeaves, err
@@ -105,7 +105,7 @@ func traverseSubtree(leafReader LayerReader, width uint64, hash HashFunc, leaves
 		WithMinHeight(RootHeightFromWidth(width)). // This ensures the correct size tree, even if padding is needed.
 		Build()
 	if err != nil {
-		return nil, nil, nil, errors.New("while building a tree: " + err.Error())
+		return nil, nil, nil, fmt.Errorf("while building a tree: %w", err)
 	}
 	for i := uint64(0); i < width; i++ {
 		leaf, err := leafReader.ReadNext()
@@ -117,11 +117,11 @@ func traverseSubtree(leafReader LayerReader, width uint64, hash HashFunc, leaves
 			leaf = externalPadding
 			shouldUseExternalPadding = false
 		} else if err != nil {
-			return nil, nil, nil, errors.New("while reading a leaf: " + err.Error())
+			return nil, nil, nil, fmt.Errorf("while reading a leaf: %w", err)
 		}
 		err = t.AddLeaf(leaf)
 		if err != nil {
-			return nil, nil, nil, errors.New("while adding a leaf: " + err.Error())
+			return nil, nil, nil, fmt.Errorf("while adding a leaf: %w", err)
 		}
 		if leavesToProve[i] {
 			provenLeaves = append(provenLeaves, leaf)
@@ -145,11 +145,11 @@ func GetNode(c CacheReader, nodePos Position) ([]byte, error) {
 		return calcNode(c, nodePos)
 	}
 	if err != nil {
-		return nil, errors.New("while seeking to Position " + nodePos.String() + " in cache: " + err.Error())
+		return nil, fmt.Errorf("while seeking to Position %s in cache: %w", nodePos, err)
 	}
 	currentVal, err := reader.ReadNext()
 	if err != nil {
-		return nil, errors.New("while reading from cache: " + err.Error())
+		return nil, fmt.Errorf("while reading from cache: %w", err)
 	}
 	return currentVal, nil
 }
@@ -173,7 +173,7 @@ func calcNode(c CacheReader, nodePos Position) ([]byte, error) {
 			break
 		}
 		if err != nil && err != io.EOF {
-			return nil, errors.New("while seeking to Position " + subtreeStart.String() + " in cache: " + err.Error())
+			return nil, fmt.Errorf("while seeking to Position %s in cache: %w", subtreeStart, err)
 		}
 		if subtreeStart.Height == 0 {
 			return PaddingValue.value, nil
@@ -184,7 +184,7 @@ func calcNode(c CacheReader, nodePos Position) ([]byte, error) {
 	width := uint64(1) << (nodePos.Height - subtreeStart.Height)
 	readerWidth, err := reader.Width()
 	if err != nil {
-		return nil, fmt.Errorf("while getting reader width: %v", err)
+		return nil, fmt.Errorf("while getting reader width: %w", err)
 	}
 	if readerWidth < subtreeStart.Index+width {
 		paddingPos := Position{
@@ -195,14 +195,14 @@ func calcNode(c CacheReader, nodePos Position) ([]byte, error) {
 		if err == ErrMissingValueAtBaseLayer {
 			paddingValue = PaddingValue.value
 		} else if err != nil {
-			return nil, errors.New("while calculating ephemeral node at Position " + paddingPos.String() + ": " + err.Error())
+			return nil, fmt.Errorf("while calculating ephemeral node at Position %s: %w", paddingPos, err)
 		}
 	}
 
 	// Traverse the subtree.
 	currentVal, _, _, err := traverseSubtree(reader, width, c.GetHashFunc(), nil, paddingValue)
 	if err != nil {
-		return nil, errors.New("while traversing subtree for root: " + err.Error())
+		return nil, fmt.Errorf("while traversing subtree for root: %w", err)
 	}
 	return currentVal, nil
 }

proving_test.go

@@ -494,8 +494,7 @@ func TestGetNode(t *testing.T) {
 	nodePos := position{}
 	node, err := GetNode(cacheReader, nodePos)
 
-	r.Error(err)
-	r.Equal("while seeking to Position <h: 0 i: 0> in cache: some error", err.Error())
+	r.EqualError(err, "while seeking to Position <h: 0 i: 0> in cache: some error")
 	r.Nil(node)
 }
 
@@ -509,8 +508,7 @@ func TestGetNode2(t *testing.T) {
 	nodePos := position{}
 	node, err := GetNode(cacheReader, nodePos)
 
-	r.Error(err)
-	r.Equal("while reading from cache: some error", err.Error())
+	r.EqualError(err, "while reading from cache: some error")
 	r.Nil(node)
 }
 
@@ -525,8 +523,7 @@ func TestGetNode3(t *testing.T) {
 	nodePos := position{Height: 1}
 	node, err := GetNode(cacheReader, nodePos)
 
-	r.Error(err)
-	r.Equal("while seeking to Position <h: 0 i: 0> in cache: some error", err.Error())
+	r.EqualError(err, "while seeking to Position <h: 0 i: 0> in cache: some error")
 	r.Nil(node)
 }
 
@@ -542,8 +539,7 @@ func TestGetNode4(t *testing.T) {
 	nodePos := position{Height: 2}
 	node, err := GetNode(cacheReader, nodePos)
 
-	r.Error(err)
-	r.Equal("while calculating ephemeral node at Position <h: 1 i: 1>: while seeking to Position <h: 0 i: 10> in cache: some error", err.Error())
+	r.EqualError(err, "while calculating ephemeral node at Position <h: 1 i: 1>: while seeking to Position <h: 0 i: 10> in cache: some error")
 	r.Nil(node)
 }
 
@@ -558,8 +554,7 @@ func TestGetNode5(t *testing.T) {
 	nodePos := position{Height: 1}
 	node, err := GetNode(cacheReader, nodePos)
 
-	r.Error(err)
-	r.Equal("while traversing subtree for root: while reading a leaf: some error", err.Error())
+	r.EqualError(err, "while traversing subtree for root: while reading a leaf: some error")
 	r.Nil(node)
 }
 
@@ -568,7 +563,6 @@ func TestCache_ValidateStructure(t *testing.T) {
 	cacheWriter := cache.NewWriter(nil, nil)
 	cacheReader, err := cacheWriter.GetReader()
 
-	r.Error(err)
-	r.Equal("reader for base layer must be included", err.Error())
+	r.EqualError(err, "reader for base layer must be included")
 	r.Nil(cacheReader)
 }

validation_test.go

@@ -321,7 +321,6 @@ func TestValidator_calcRoot(t *testing.T) {
 
 	root, _, err := v.CalcRoot(0)
 
-	r.Error(err)
-	r.Equal("no more items", err.Error())
+	r.EqualError(err, "no more items")
 	r.Nil(root)
 }