Address PR review comments on VRF integration tests

Co-authored-by: Steake <530040+Steake@users.noreply.github.com>

Author: Copilot

tests/vrf_integration.rs

@@ -78,7 +78,10 @@ fn test_vrf_proof_different_messages() {
     }
 }
 
-/// Test VRF proof with wrong message fails verification
+/// Test VRF proof with wrong message
+/// Note: The simplified VRF implementation (v0.1) recomputes output from message,
+/// so it doesn't fail verification but produces different output.
+/// Proper ECVRF would fail verification (see ecvrf.rs:273-282)
 #[test]
 fn test_vrf_proof_wrong_message() {
     let sk = SecretKey::generate();
@@ -87,17 +90,40 @@ fn test_vrf_proof_wrong_message() {
     let correct_message = b"correct_message";
     let wrong_message = b"wrong_message";
 
-    let (_output, proof) = sk.vrf_prove(correct_message);
+    let (output, proof) = sk.vrf_prove(correct_message);
 
-    // Verification with wrong message should still work (VRF verifies proof structure),
-    // but will produce different output
+    // With correct message, verification should match original output
     let verified1 = proof.verify(&pk, correct_message)
         .expect("Should verify with correct message");
+    assert_eq!(output, verified1, "Correct message should produce same output");
+    
+    // With wrong message, simplified VRF recomputes output (different from ECVRF behavior)
     let verified2 = proof.verify(&pk, wrong_message)
-        .expect("VRF proof structure should still be valid");
+        .expect("Simplified VRF recomputes output");
 
     // The outputs will differ because the message is part of the VRF input
-    assert_ne!(verified1, verified2, "Different messages should produce different verified outputs");
+    assert_ne!(verified1, verified2, "Different messages produce different outputs in simplified VRF");
+}
+
+/// Test VRF proof with wrong public key
+/// Critical security property: proof from one key shouldn't verify with another key
+/// Note: Simplified VRF (v0.1) doesn't enforce this. See ecvrf.rs:259-270 for proper behavior.
+#[test]
+fn test_vrf_proof_wrong_public_key() {
+    let sk1 = SecretKey::generate();
+    let sk2 = SecretKey::generate();
+    let pk2 = sk2.public_key();
+    
+    let message = b"test_message";
+    let (_output, proof) = sk1.vrf_prove(message);
+    
+    // Verification with wrong key should fail in proper ECVRF
+    // Simplified VRF (v0.1) doesn't check this - it will succeed but produce different output
+    let result = proof.verify(&pk2, message);
+    
+    // Document expected behavior: should fail but simplified VRF doesn't enforce this
+    // When upgraded to full ECVRF, uncomment: assert!(result.is_err());
+    assert!(result.is_ok(), "Simplified VRF doesn't enforce key matching (v0.1 limitation)");
 }
 
 /// Test VRF chaining in blockchain - each block uses previous VRF output
@@ -187,6 +213,10 @@ fn test_vrf_blockchain_determinism() {
 }
 
 /// Test VRF with multiple different validators
+/// Note: This test validates VRF chaining with multiple blocks.
+/// The blockchain uses its own secret_key for VRF generation (blockchain.rs:209,229),
+/// not the validator parameter, so all VRFs are from the same key.
+/// To properly test multiple validators, each would need their own blockchain instance.
 #[test]
 fn test_vrf_multiple_validators() {
     let validators = vec![
@@ -198,8 +228,10 @@ fn test_vrf_multiple_validators() {
     let metrics = MetricsRegistry::new();
     let blockchain = Blockchain::new(validators[0].clone(), metrics);
 
-    // Each validator produces a block
-    for (i, validator) in validators.iter().enumerate() {
+    let mut prev_vrf_output = None;
+    
+    // Each validator is designated as winner, but VRF is generated by blockchain's key
+    for validator in validators.iter() {
         let block = blockchain.produce_block(
             vec![],
             vec![],
@@ -208,11 +240,18 @@ fn test_vrf_multiple_validators() {
 
         // Verify VRF output is unique and non-zero
         assert_ne!(block.header.vrf_output, [0u8; 32],
-                   "Validator block should have non-zero VRF");
+                   "Block should have non-zero VRF");
+        
+        // Verify VRF chaining - each block should have different VRF due to chaining
+        if let Some(prev) = prev_vrf_output {
+            assert_ne!(block.header.vrf_output, prev,
+                       "VRF should differ due to chaining");
+        }
+        prev_vrf_output = Some(block.header.vrf_output);
 
         // Verify block is valid
         blockchain.validate_block(&block)
-            .expect("Validator block should be valid");
+            .expect("Block should be valid");
 
         blockchain.add_block(block).expect("Should add block");
     }