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

mod group;
mod test;

pub use group::*;
pub use test::*;

/// Weierstrass standard curve operation macro
#[macro_export]
macro_rules! weierstrass_curve_operation {
    ($scalar:ident, $range:ident, $a:ident, $b:ident, $b3:ident, $affine:ident, $projective:ident, $x:ident, $y:ident) => {
        use zkstd::common::*;
        use zkstd::common::*;

        affine_group_operation!($affine, $projective, $range, $scalar, $x, $y, $a);
        projective_group_operation!($affine, $projective, $range, $scalar, $x, $y, $a);
        mixed_curve_operations!($affine, $projective);

        impl ParityCmp for $affine {}
        impl ParityCmp for $projective {}
        impl Basic for $affine {}
        impl Basic for $projective {}
        impl ParallelCmp for $affine {}
        impl ParallelCmp for $projective {}

        impl WeierstrassCurve for $affine {
            const PARAM_B: $range = $b;
            const PARAM_3B: $range = $b3;
        }

        impl CurveAffine for $affine {
            fn to_extended(self) -> $projective {
                if self.is_identity() {
                    $projective::ADDITIVE_IDENTITY
                } else {
                    $projective {
                        x: self.x,
                        y: self.y,
                        z: Self::Range::one(),
                    }
                }
            }

            fn to_raw_bytes(self) -> Vec<u8> {
                self.to_bytes().to_vec()
            }
        }

        impl WeierstrassAffine for $affine {
            type Projective = $projective;

            fn to_projective(self) -> $projective {
                if self.is_identity() {
                    $projective::ADDITIVE_IDENTITY
                } else {
                    $projective {
                        x: self.x,
                        y: self.y,
                        z: Self::Range::one(),
                    }
                }
            }
        }

        impl WeierstrassCurve for $projective {
            const PARAM_B: $range = $b;
            const PARAM_3B: $range = $b3;
        }

        impl CurveExtended for $projective {
            fn to_affine(self) -> Self::Affine {
                match self.z.invert() {
                    Some(z_inv) => Self::Affine {
                        x: self.x * z_inv,
                        y: self.y * z_inv,
                        is_infinity: false,
                    },
                    None => Self::Affine::ADDITIVE_IDENTITY,
                }
            }

            fn get_z(&self) -> Self::Range {
                self.z
            }
        }

        impl WeierstrassProjective for $projective {
            fn new(x: Self::Range, y: Self::Range, z: Self::Range) -> Self {
                Self { x, y, z }
            }
        }

        impl From<$projective> for $affine {
            fn from(p: $projective) -> $affine {
                p.to_affine()
            }
        }

        impl From<$affine> for $projective {
            fn from(a: $affine) -> $projective {
                a.to_extended()
            }
        }
    };
}

pub use weierstrass_curve_operation;