ark-mpc 0.1.2

Malicious-secure SPDZ style two party secure computation
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

//! Defines macros useful for creating arithmetic implementations

/// Given an implementation of an arithmetic trait on two borrowed references,
/// this macro implements the same arithmetic on the owned and partially-owned
/// variants
macro_rules! impl_borrow_variants {
    // Single type trait
    ($target:ty, $trait:ident, $fn_name:ident, $op:tt, $($gen:ident: $gen_ty:ident),*) => {
        // Single implementation, owned target type
        impl<$($gen:$gen_ty),*> $trait for $target {
            type Output = $target;

            fn $fn_name(self) -> Self::Output {
                $op &self
            }
        }
    };

    // Output type same as left hand side
    ($lhs:ty, $trait:ident, $fn_name:ident, $op:tt, $rhs:ty, $($gen:ident: $gen_ty:ident),*) => {
        impl_borrow_variants!($lhs, $trait, $fn_name, $op, $rhs, Output=$lhs, $($gen: $gen_ty),*);
    };

    // Output type specified
    ($lhs:ty, $trait:ident, $fn_name:ident, $op:tt, $rhs:ty, Output=$out_type:ty, $($gen:ident: $gen_ty:ident),*) => {
        /// lhs borrowed, rhs owned
        impl<'a, $($gen: $gen_ty),*> $trait<$rhs> for &'a $lhs {
            type Output = $out_type;

            fn $fn_name(self, rhs: $rhs) -> Self::Output {
                self $op &rhs
            }
        }

        /// lhs owned, rhs borrowed
        impl<'a, $($gen: $gen_ty),*> $trait<&'a $rhs> for $lhs {
            type Output = $out_type;

            fn $fn_name(self, rhs: &'a $rhs) -> Self::Output {
                &self $op rhs
            }
        }

        /// lhs owned, rhs owned
        impl<$($gen: $gen_ty),*> $trait<$rhs> for $lhs {
            type Output = $out_type;

            fn $fn_name(self, rhs: $rhs) -> Self::Output {
                &self $op &rhs
            }
        }
    }
}

/// A macro to implement commutative variants of a binary operation
macro_rules! impl_commutative {
    ($lhs:ty, $trait:ident, $fn_name:ident, $op:tt, $rhs:ty, $($gen:ident: $gen_ty:ident),*) => {
        impl_commutative!($lhs, $trait, $fn_name, $op, $rhs, Output=$lhs, $($gen: $gen_ty),*);
    };

    ($lhs:ty, $trait:ident, $fn_name:ident, $op:tt, $rhs:ty, Output=$out_type:ty, $($gen:ident: $gen_ty:ident),*) => {
        /// lhs borrowed, rhs borrowed
        impl<'a, $($gen: $gen_ty),*> $trait<&'a $lhs> for &'a $rhs {
            type Output = $out_type;

            fn $fn_name(self, rhs: &'a $lhs) -> Self::Output {
                rhs $op self
            }
        }

        /// lhs borrowed, rhs owned
        impl<'a, $($gen: $gen_ty),*> $trait<$lhs> for &'a $rhs
        {
            type Output = $out_type;

            fn $fn_name(self, rhs: $lhs) -> Self::Output {
                &rhs $op self
            }
        }

        /// lhs owned, rhs borrowed
        impl<'a, $($gen: $gen_ty),*> $trait<&'a $lhs> for $rhs
        {
            type Output = $out_type;

            fn $fn_name(self, rhs: &'a $lhs) -> Self::Output {
                rhs $op &self
            }
        }

        /// lhs owned, rhs owned
        impl<$($gen: $gen_ty),*> $trait<$lhs> for $rhs
        {
            type Output = $out_type;

            fn $fn_name(self, rhs: $lhs) -> Self::Output {
                &rhs $op &self
            }
        }
    };
}

pub(crate) use impl_borrow_variants;
pub(crate) use impl_commutative;