zkstd 0.0.22

zero knowledge proof standard library
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

#[macro_export]
macro_rules! field_test {
    ($test_name:ident, $field:ident, $iter_times:expr) => {
        paste! {
            #[test]
            fn [< $test_name _comparator_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);
                    let b = a.square();

                    assert!(a == a);
                    assert!(a >= a);
                    assert!(a <= a);
                    assert!(!(a > a));
                    assert!(!(a < a));
                    assert!(a != b);
                }
            }
        }

        paste! {
            #[test]
            fn [< $test_name _addition_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);

                    // a + a = a * 2
                    let b = a + a;
                    let c = a.double();

                    assert_eq!(b, c);
                }
            }
        }

        paste! {
            #[test]
            fn [< $test_name _subtraction_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);

                    // a - a = a * 2 - a * 2
                    let b = a - a;
                    let c = a.double();
                    let d = a.double();
                    let e = c - d;

                    assert_eq!(b, e);
                }
            }
        }

        paste! {
            #[test]
            fn [< $test_name _multiplication_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);
                    let b = $field::random(OsRng);
                    let c = $field::random(OsRng);

                    // a * b + a * c
                    let ab = a * b;
                    let ac = a * c;
                    let d = ab + ac;

                    // a * (b + c)
                    let bc = b + c;
                    let e = a * bc;

                    assert_eq!(d, e);
                }
            }
        }

        paste! {
            #[test]
            fn [< $test_name _squaring_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);
                    let b = $field::random(OsRng);

                    // (a * a) * (b * b)
                    let aa = a * a;
                    let bb = b * b;
                    let c = aa * bb;

                    // a^2 * b^2
                    let aa = a.square();
                    let bb = b.square();
                    let d = aa * bb;

                    assert_eq!(c, d);
                }
            }
        }

        paste! {
            #[test]
            fn [< $test_name _inversion_test >]() {
                for _ in 0..$iter_times {
                    let a = $field::random(OsRng);

                    // a * a^-1 = e
                    let inv = a.invert();

                    match inv {
                        Some(x) => {
                            let b = a * x;
                            assert_eq!(b, $field::one())
                        },
                        None => {}
                    }
                }
            }
        }
    };
}

pub use field_test;