spcial case when a subtree len is a pow of 2

Author: phbnf

proof/proof.go

@@ -139,10 +139,8 @@ func SubtreeConsistency(start, end, size uint64) (Nodes, error) {
 	// into this node in the tree of the given size.
 	p := nodes(index, level, size)
 
-	// Handle the case when end is a power of 2.
-	// TODO: do we also need to do taht for a full subtree?
-	// if first node is the root of the subtree.
-	if index == 0 {
+	// Handle the case when the subtree size if a power of 2.
+	if (end-start)&(end-start-1) == 0 {
 		return p.skipFirst(), nil
 	}
 	return p, nil

proof/proof_test.go

@@ -484,15 +484,16 @@ func TestSubtreeConsistency(t *testing.T) {
 		{start: 0, end: 7, size: 8, want: nodes(
 			id(0, 6), id(0, 7), id(1, 2), id(2, 0))}, // g h cc aaa
 		// start > 0
-		{start: 1, end: 2, size: 3, want: rehash(2, 3, id(0, 1), id(0, 0), id(0, 2))},                     // b a c
-		{start: 1, end: 2, size: 5, want: rehash(3, 4, id(0, 1), id(0, 0), id(1, 1), id(0, 4))},           // b a bb e
-		{start: 2, end: 4, size: 5, want: rehash(2, 3, id(1, 1), id(1, 0), id(0, 4))},                     // bb aa e
-		{start: 1, end: 2, size: 7, want: rehash(3, 5, id(0, 1), id(0, 0), id(1, 1), id(0, 6), id(1, 2))}, // b a bb g cc
-		{start: 2, end: 4, size: 10, want: rehash(3, 4, id(1, 1), id(1, 0), id(2, 1), id(1, 4))},          // bb aa bbb ee
+		{start: 1, end: 2, size: 3, want: rehash(1, 2, id(0, 0), id(0, 2))},                     // a c
+		{start: 1, end: 2, size: 5, want: rehash(2, 3, id(0, 0), id(1, 1), id(0, 4))},           // a bb e
+		{start: 2, end: 4, size: 5, want: rehash(1, 2, id(1, 0), id(0, 4))},                     // aa e
+		{start: 1, end: 2, size: 7, want: rehash(2, 4, id(0, 0), id(1, 1), id(0, 6), id(1, 2))}, // a bb g cc
+		{start: 2, end: 4, size: 10, want: rehash(2, 3, id(1, 0), id(2, 1), id(1, 4))},          // aa bbb ee
+		{start: 4, end: 6, size: 10, want: rehash(2, 3, id(1, 3), id(2, 0), id(1, 4))},          // dd aaa ee
 		{start: 4, end: 7, size: 11, want: rehash(4, 6, // ccc=hash(ee,k)
 			id(0, 6), id(0, 7), id(1, 2), id(2, 0), id(0, 10), id(1, 4))}, // g h cc aaa k ee
-		{start: 4, end: 8, size: 11, want: rehash(2, 4, // ccc=hash(ee,k)
-			id(2, 1), id(2, 0), id(0, 10), id(1, 4))}, // bbb aaa k ee
+		{start: 4, end: 8, size: 11, want: rehash(1, 3, // ccc=hash(ee,k)
+			id(2, 0), id(0, 10), id(1, 4))}, // aaa k ee
 		{start: 8, end: 13, size: 15, want: rehash(2, 3,
 			id(0, 12), id(0, 13), id(0, 14), id(2, 2), id(3, 0))}, // m n  o ccc aaaa
 		{start: 8, end: 14, size: 15, want: rehash(1, 2, // hh=hash(o)
@@ -522,16 +523,16 @@ func TestSubtreeConsistency(t *testing.T) {
 		{start: 0, end: 1, size: 7, want: rehash(2, 4, // bbb=hash(cc,g)
 			id(0, 1), id(1, 1), id(0, 6), id(1, 2))}, // b bb g cc
 		// start > 0
-		{start: 2, end: 4, size: 6, want: rehash(2, 3, // bbb=hash(cc)
-			id(1, 1), id(1, 0), id(1, 2))}, // bb, aa, cc
+		{start: 2, end: 4, size: 6, want: rehash(1, 2, // bbb=hash(cc)
+			id(1, 0), id(1, 2))}, // aa, cc
 		{start: 4, end: 7, size: 9, want: rehash(4, 5, // bbbb=hash(i)
 			id(0, 6), id(0, 7), id(1, 2), id(2, 0), id(0, 8))}, // g h cc aaa i
 		{start: 4, end: 7, size: 10, want: rehash(4, 5, // bbbb=hash(ee)
 			id(0, 6), id(0, 7), id(1, 2), id(2, 0), id(1, 4))}, // g h cc aaa ee
-		{start: 4, end: 8, size: 10, want: rehash(2, 3,
-			id(2, 1), id(2, 0), id(1, 4))}, // cc
-		{start: 2, end: 3, size: 9, want: rehash(4, 5, // bbbb=hash(i)
-			id(0, 2), id(0, 3), id(1, 0), id(2, 1), id(0, 8))}, // b bb g cc
+		{start: 4, end: 8, size: 10, want: rehash(1, 2,
+			id(2, 0), id(1, 4))}, // cc
+		{start: 2, end: 3, size: 9, want: rehash(3, 4, // bbbb=hash(i)
+			id(0, 3), id(1, 0), id(2, 1), id(0, 8))}, // b bb g cc
 
 		// Some rehashes in the middle of the returned list.
 		{start: 0, end: 10, size: 15, want: rehash(2, 4,