arcium-primitives 0.4.0

Arcium primitives
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

use std::ops::Mul;

use super::{CurveKey, GlobalFieldKey};
use crate::{
    algebra::elliptic_curve::{BaseField, Curve, Point, ScalarField},
    sharing::FieldShareKey,
};

pub type GlobalScalarKey<C> = GlobalFieldKey<ScalarField<C>>;
pub type GlobalBaseKey<C> = GlobalFieldKey<BaseField<C>>;

pub type ScalarKey<C> = FieldShareKey<ScalarField<C>>;
pub type BaseKey<C> = FieldShareKey<BaseField<C>>;

// === Curve point multiplication === //

impl<'a, C: Curve> Mul<&'a Point<C>> for &'a ScalarKey<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: &'a Point<C>) -> Self::Output {
        CurveKey {
            alpha: self.alpha.clone(),
            beta: other * self.beta,
        }
    }
}

impl<'a, C: Curve> Mul<&'a Point<C>> for ScalarKey<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: &'a Point<C>) -> Self::Output {
        CurveKey {
            alpha: self.alpha,
            beta: other * self.beta,
        }
    }
}

impl<C: Curve> Mul<Point<C>> for &ScalarKey<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: Point<C>) -> Self::Output {
        CurveKey {
            alpha: self.alpha.clone(),
            beta: other * self.beta,
        }
    }
}

impl<C: Curve> Mul<Point<C>> for ScalarKey<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: Point<C>) -> Self::Output {
        CurveKey {
            alpha: self.alpha,
            beta: other * self.beta,
        }
    }
}

impl<'a, C: Curve> Mul<&'a ScalarKey<C>> for &'a Point<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: &'a ScalarKey<C>) -> Self::Output {
        CurveKey {
            alpha: other.alpha.clone(),
            beta: self * other.beta,
        }
    }
}

impl<'a, C: Curve> Mul<&'a ScalarKey<C>> for Point<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: &'a ScalarKey<C>) -> Self::Output {
        CurveKey {
            alpha: other.alpha.clone(),
            beta: self * other.beta,
        }
    }
}

impl<C: Curve> Mul<ScalarKey<C>> for &Point<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: ScalarKey<C>) -> Self::Output {
        CurveKey {
            alpha: other.alpha,
            beta: other.beta * self,
        }
    }
}

impl<C: Curve> Mul<ScalarKey<C>> for Point<C> {
    type Output = CurveKey<C>;

    #[inline]
    fn mul(self, other: ScalarKey<C>) -> Self::Output {
        CurveKey {
            alpha: other.alpha,
            beta: self * other.beta,
        }
    }
}