merkledb -- verify range proof in fuzz test; fix bound error

x/merkledb/proof.go

@@ -303,12 +303,28 @@ func (proof *RangeProof) Verify(
 		return err
 	}
 
-	largestKey := end
+	// [proof] allegedly provides and proves all key-value
+	// pairs in [smallestProvenPath, largestProvenPath].
+	// If [smallestProvenPath] is Nothing, [proof] should
+	// provide and prove all keys < [largestProvenPath].
+	// If [largestProvenPath] is Nothing, [proof] should
+	// provide and prove all keys > [smallestProvenPath].
+	// If both are Nothing, [proof] should prove the entire trie.
+	smallestProvenPath := Nothing[path]()
+	if start != nil {
+		smallestProvenPath = Some(newPath(start))
+	}
+
+	largestProvenPath := Nothing[path]()
+	if end != nil {
+		largestProvenPath = Some(newPath(end))
+	}
+
 	if len(proof.KeyValues) > 0 {
 		// If [proof] has key-value pairs, we should insert children
-		// greater than [largestKey] to ancestors of the node containing
-		// [largestKey] so that we get the expected root ID.
-		largestKey = proof.KeyValues[len(proof.KeyValues)-1].Key
+		// greater than [largestProvenPath] to ancestors of the node containing
+		// [largestProvenPath] so that we get the expected root ID.
+		largestProvenPath = Some(newPath(proof.KeyValues[len(proof.KeyValues)-1].Key))
 	}
 
 	// The key-value pairs (allegedly) proven by [proof].
@@ -317,24 +333,31 @@ func (proof *RangeProof) Verify(
 		keyValues[newPath(keyValue.Key)] = keyValue.Value
 	}
 
-	smallestPath := newPath(start)
-	largestPath := newPath(largestKey)
-
 	// Ensure that the start proof is valid and contains values that
 	// match the key/values that were sent.
-	if err := verifyProofPath(proof.StartProof, smallestPath); err != nil {
+	if err := verifyProofPath(proof.StartProof, smallestProvenPath.Value()); err != nil {
 		return err
 	}
-	if err := verifyAllRangeProofKeyValuesPresent(proof.StartProof, smallestPath, largestPath, keyValues); err != nil {
+	if err := verifyAllRangeProofKeyValuesPresent(
+		proof.StartProof,
+		smallestProvenPath.Value(),
+		largestProvenPath.Value(),
+		keyValues,
+	); err != nil {
 		return err
 	}
 
 	// Ensure that the end proof is valid and contains values that
 	// match the key/values that were sent.
-	if err := verifyProofPath(proof.EndProof, largestPath); err != nil {
+	if err := verifyProofPath(proof.EndProof, largestProvenPath.Value()); err != nil {
 		return err
 	}
-	if err := verifyAllRangeProofKeyValuesPresent(proof.EndProof, smallestPath, largestPath, keyValues); err != nil {
+	if err := verifyAllRangeProofKeyValuesPresent(
+		proof.EndProof,
+		smallestProvenPath.Value(),
+		largestProvenPath.Value(),
+		keyValues,
+	); err != nil {
 		return err
 	}
 
@@ -352,32 +375,24 @@ func (proof *RangeProof) Verify(
 	}
 
 	// For all the nodes along the edges of the proof, insert children
-	// < [insertChildrenLessThan] and > [insertChildrenGreaterThan]
+	// < [smallestProvenPath] and > [largestProvenPath]
 	// into the trie so that we get the expected root ID (if this proof is valid).
-	// By inserting all children < [insertChildrenLessThan], we prove that there are no keys
-	// > [insertChildrenLessThan] but less than the first key given.
+	// By inserting all children < [smallestProvenPath], we prove that there are no keys
+	// > [smallestProvenPath] but less than the first key given.
 	// That is, the peer who gave us this proof is not omitting nodes.
-	insertChildrenLessThan := Nothing[path]()
-	if len(smallestPath) > 0 {
-		insertChildrenLessThan = Some(smallestPath)
-	}
-	insertChildrenGreaterThan := Nothing[path]()
-	if len(largestPath) > 0 {
-		insertChildrenGreaterThan = Some(largestPath)
-	}
 	if err := addPathInfo(
 		view,
 		proof.StartProof,
-		insertChildrenLessThan,
-		insertChildrenGreaterThan,
+		smallestProvenPath,
+		largestProvenPath,
 	); err != nil {
 		return err
 	}
 	if err := addPathInfo(
 		view,
 		proof.EndProof,
-		insertChildrenLessThan,
-		insertChildrenGreaterThan,
+		smallestProvenPath,
+		largestProvenPath,
 	); err != nil {
 		return err
 	}

x/merkledb/proof_test.go

@@ -1713,6 +1713,16 @@ func FuzzRangeProofInvariants(f *testing.F) {
 		)
 		require.NoError(err)
 
+		rootID, err := db.GetMerkleRoot(context.Background())
+		require.NoError(err)
+
+		require.NoError(rangeProof.Verify(
+			context.Background(),
+			start,
+			end,
+			rootID,
+		))
+
 		// Make sure the start proof doesn't contain any nodes
 		// that are in the end proof.
 		endProofKeys := set.Set[path]{}