better isSubtreeValid

Author: phbnf

proof/proof.go

@@ -59,15 +59,12 @@ func Inclusion(index, size uint64) (Nodes, error) {
 //   - start to be a multiple of the smallest power of two greater than or equal to
 //     (end - start)
 func SubtreeInclusion(index, start, end uint64) (Nodes, error) {
-	if start >= end {
-		return Nodes{}, fmt.Errorf("start %d greater than or equal to end %d", start, end)
+	if err := IsSubtreeValid(start, end); err != nil {
+		return Nodes{}, fmt.Errorf("subtree invalid: %v", err)
 	}
 	if index < start || index >= end {
 		return Nodes{}, fmt.Errorf("index %d out of bounds for subtree [%d, %d)", index, start, end)
 	}
-	if err := isSubtreeValid(start, end); err != nil {
-		return Nodes{}, fmt.Errorf("subtree invalid: %v", err)
-	}
 
 	// Shift the subtree to the left, such that it starts at 0.
 	p := nodes(index-start, 0, end-start).skipFirst()
@@ -223,26 +220,33 @@ func reverse(ids []compact.NodeID) {
 	}
 }
 
-// isSubtreeValid returns whether a subtree covers a valid range.
+// IsSubtreeValid returns whether a subtree covers a valid range.
 // A subtree is valid if there exist a parent tree node to:
 // - all the subtree nodes
 // - no extra node to the left of the subtree
 // - potentially extra nodes to the right of the subtree
-func isSubtreeValid(start, end uint64) error {
-	l := end - start
+func IsSubtreeValid(start, end uint64) error {
+	if start >= end {
+		return fmt.Errorf("start %d must be strictly less than end %d", start, end)
+	}
 	if start == 0 {
 		return nil
-	} else if l > uint64(1)<<63 {
-		// special-case large subtree to avoid panic
+	}
+
+	l := end - start
+
+	// special-case large subtree to avoid panic
+	if l > uint64(1)<<63 {
 		return fmt.Errorf("start %d must be 0 when subtree length %d > 1<<63. ", start, l)
 	}
-	if bc := bitCeil(l); start%bc != 0 {
+	if bc := bitCeil(l); start&(bc-1) != 0 {
 		return fmt.Errorf("start %d not a multiple of bit_ceil(end - start) = %d", start, bc)
 	}
+
 	return nil
 }
 
-// bitCeil returns the smallest power of 2 larger than n.
+// bitCeil returns the smallest power of 2 larger or equal than n.
 // MUST NOT be used with n larger than uint64(1)<<63.
 func bitCeil(n uint64) uint64 {
 	if n <= 1 {

proof/proof_test.go

@@ -425,7 +425,7 @@ func TestInclusionSubtreeSucceedsUpToTreeSize(t *testing.T) {
 	const maxSize = uint64(555)
 	for sbe := uint64(1); sbe <= maxSize; sbe++ {
 		for sbs := range sbe {
-			if err := isSubtreeValid(sbs, sbe); err != nil {
+			if err := IsSubtreeValid(sbs, sbe); err != nil {
 				continue
 			}
 			for i := sbs; i < sbe; i++ {

proof/verify.go

@@ -65,7 +65,7 @@ func VerifySubtreeInclusion(hasher merkle.LogHasher, index, start, end uint64, l
 	if index < start || index >= end {
 		return fmt.Errorf("index %d out of bounds for subtree [%d, %d)", index, start, end)
 	}
-	if err := isSubtreeValid(start, end); err != nil {
+	if err := IsSubtreeValid(start, end); err != nil {
 		return fmt.Errorf("subtree invalid: %v", err)
 	}
 	calcRoot, err := RootFromInclusionProof(hasher, index-start, end-start, leafHash, proof)

testonly/tree_fuzz_test.go

@@ -3,7 +3,6 @@ package testonly
 import (
 	"bytes"
 	"math"
-	"math/bits"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -86,8 +85,7 @@ func FuzzSubtreeInclusionProofAndVerify(f *testing.F) {
 		if end >= math.MaxUint16 {
 			return
 		}
-		t.Logf("index=%d, start=%d, end=%d", index, start, end)
-		if start >= end {
+		if err := proof.IsSubtreeValid(start, end); err != nil {
 			return
 		}
 		if index < start {
@@ -96,9 +94,6 @@ func FuzzSubtreeInclusionProofAndVerify(f *testing.F) {
 		if index >= end {
 			return
 		}
-		if bc := uint64(1) << bits.Len64(end-start-1); start%bc != 0 {
-			return
-		}
 		tree := newTree(genEntries(end))
 		p, err := tree.SubtreeInclusionProof(index, start, end)
 		t.Logf("proof=%v", p)