arcis 0.12.0

A standard library of types and functions for writing MPC circuits with the Arcis framework.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Methods and associated constants on primitive integer types accepted by
//! the arcis interpreter.
//!
//! Each integer type listed here (`u8`, `u16`, …, `i128`, `usize`, `isize`)
//! is a documentation-only unit struct shadowing the primitive of the same
//! name within this module. The associated items mirror what the arcis
//! interpreter accepts inside `#[encrypted]` code; the values shown for
//! `BITS`/`MIN`/`MAX` are the primitive's own (clicking the type takes you to
//! the primitive's std page).

const STUB_MSG: &str = "arcis::std::integer is documentation-only; \
    inside `#[encrypted]` code the interpreter intercepts the real method before this stub runs.";

macro_rules! supported_int_common {
    ($t:ident, $primitive:ty, $bytes:literal) => {
        impl $t {
            /// Mirrors the primitive's `BITS` associated constant.
            pub const BITS: ::core::primitive::u32 = <$primitive>::BITS;
            /// Mirrors the primitive's `MIN` associated constant.
            pub const MIN: $primitive = <$primitive>::MIN;
            /// Mirrors the primitive's `MAX` associated constant.
            pub const MAX: $primitive = <$primitive>::MAX;

            /// Returns the smaller of `self` and `other`. Mirrors [`Ord::min`].
            pub fn min(self, other: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Returns the larger of `self` and `other`. Mirrors [`Ord::max`].
            pub fn max(self, other: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Computes the absolute difference between `self` and `other`.
            pub fn abs_diff(self, other: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Computes `self.div_ceil(other)` (ceiling division).
            pub fn div_ceil(self, other: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Wrapping (modular) addition.
            ///
            /// **Only works on integers whose type is statically known to the interpreter.**
            pub fn wrapping_add(self, rhs: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Wrapping (modular) subtraction.
            ///
            /// **Only works on integers whose type is statically known to the interpreter.**
            pub fn wrapping_sub(self, rhs: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Wrapping (modular) multiplication.
            ///
            /// **Only works on integers whose type is statically known to the interpreter.**
            pub fn wrapping_mul(self, rhs: Self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Returns the bytes of `self` in little-endian order.
            ///
            /// **Only works on integers whose type is statically known to the interpreter.**
            pub fn to_le_bytes(self) -> [::core::primitive::u8; $bytes] {
                unimplemented!("{STUB_MSG}")
            }

            /// Returns the bytes of `self` in big-endian order.
            ///
            /// **Only works on integers whose type is statically known to the interpreter.**
            pub fn to_be_bytes(self) -> [::core::primitive::u8; $bytes] {
                unimplemented!("{STUB_MSG}")
            }
        }
    };
}

macro_rules! supported_int_signed_only {
    ($t:ident) => {
        impl $t {
            /// Returns the absolute value of `self`.
            pub fn abs(self) -> Self {
                unimplemented!("{STUB_MSG}")
            }

            /// Returns `true` if `self` is strictly greater than zero.
            pub fn is_positive(self) -> ::core::primitive::bool {
                unimplemented!("{STUB_MSG}")
            }

            /// Returns `true` if `self` is strictly less than zero.
            pub fn is_negative(self) -> ::core::primitive::bool {
                unimplemented!("{STUB_MSG}")
            }
        }
    };
}

macro_rules! supported_unsigned {
    ($t:ident, $primitive:ty, $bytes:literal) => {
        /// Supported items on this integer type inside `#[encrypted]` code.
        #[allow(non_camel_case_types)]
        pub struct $t;
        supported_int_common!($t, $primitive, $bytes);
    };
}

macro_rules! supported_signed {
    ($t:ident, $primitive:ty, $bytes:literal) => {
        /// Supported items on this integer type inside `#[encrypted]` code.
        #[allow(non_camel_case_types)]
        pub struct $t;
        supported_int_common!($t, $primitive, $bytes);
        supported_int_signed_only!($t);
    };
}

supported_unsigned!(u8, ::core::primitive::u8, 1);
supported_unsigned!(u16, ::core::primitive::u16, 2);
supported_unsigned!(u32, ::core::primitive::u32, 4);
supported_unsigned!(u64, ::core::primitive::u64, 8);
supported_unsigned!(u128, ::core::primitive::u128, 16);
supported_unsigned!(usize, ::core::primitive::usize, 8);

supported_signed!(i8, ::core::primitive::i8, 1);
supported_signed!(i16, ::core::primitive::i16, 2);
supported_signed!(i32, ::core::primitive::i32, 4);
supported_signed!(i64, ::core::primitive::i64, 8);
supported_signed!(i128, ::core::primitive::i128, 16);
supported_signed!(isize, ::core::primitive::isize, 8);