clock-rand 1.0.3

Next-generation random number generation with blockchain-aware RNGs, fork detection, and cryptographic security
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Fork detection and reseeding tests

#[cfg(test)]
#[cfg(feature = "custom_rng")]
mod tests {
    use clock_rand::*;

    #[test]
    fn test_fork_detection() {
        let hash1 = [0x01u8; 32];
        let hash2 = [0x02u8; 32];

        let mut rng = ChainSeedX::builder()
            .with_block_hash(hash1)
            .with_fork_detection(true)
            .build()
            .unwrap();

        // Different hash should trigger fork
        let fork_detected = rng.check_fork(&hash2).unwrap();
        assert!(fork_detected);
    }

    #[test]
    fn test_fork_reseeding() {
        let hash1 = [0x01u8; 32];
        let hash2 = [0x02u8; 32];

        let mut rng1 = ChainSeedX::builder()
            .with_block_hash(hash1)
            .build()
            .unwrap();

        let mut rng2 = ChainSeedX::builder()
            .with_block_hash(hash1)
            .build()
            .unwrap();

        // Generate some values
        let v1 = <ChainSeedX as Rng>::next_u64(&mut rng1);
        let v2 = <ChainSeedX as Rng>::next_u64(&mut rng2);
        assert_eq!(v1, v2);

        // Fork detected on rng1
        let fork_detected = rng1.check_fork(&hash2).unwrap();
        assert!(fork_detected);

        // Now they should diverge
        assert_ne!(
            <ChainSeedX as Rng>::next_u64(&mut rng1),
            <ChainSeedX as Rng>::next_u64(&mut rng2)
        );
    }

    #[test]
    fn test_update_block() {
        let hash1 = [0x01u8; 32];
        let hash2 = [0x02u8; 32];

        let mut rng = ChainSeedX::builder()
            .with_block_hash(hash1)
            .build()
            .unwrap();

        // Generate a value before update
        let value_before = <ChainSeedX as Rng>::next_u64(&mut rng);

        // Update with new block (no fork since it's the first block)
        rng.update_block(&hash2, 12345).unwrap();

        // RNG should still work and produce different values due to reseeding
        let value_after = <ChainSeedX as Rng>::next_u64(&mut rng);
        assert_ne!(value_before, value_after);
    }
}