arcis-compiler 0.9.7

A framework for writing secure multi-party computation (MPC) circuits to be executed on the Arcium network.
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

use crate::utils::{
    curve_point::CurvePoint,
    field::{BaseField, ScalarField},
};
use serde::{Deserialize, Serialize};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DomainElement<T, U, V, W> {
    Bit(T),
    Scalar(U),
    Base(V),
    Curve(W),
}

impl<T, U, V, W> DomainElement<T, U, V, W> {
    pub fn same_domain<T_, U_, V_, W_>(&self, other: &DomainElement<T_, U_, V_, W_>) -> bool {
        match (self, other) {
            (DomainElement::Bit(_), DomainElement::Bit(_)) => true,
            (DomainElement::Scalar(_), DomainElement::Scalar(_)) => true,
            (DomainElement::Base(_), DomainElement::Base(_)) => true,
            (DomainElement::Curve(_), DomainElement::Curve(_)) => true,
            (_, _) => false,
        }
    }
    pub fn to_domain(&self) -> DomainElement<(), (), (), ()> {
        match self {
            DomainElement::Bit(_) => DomainElement::Bit(()),
            DomainElement::Scalar(_) => DomainElement::Scalar(()),
            DomainElement::Base(_) => DomainElement::Base(()),
            DomainElement::Curve(_) => DomainElement::Curve(()),
        }
    }
}

pub trait Domain<T, U, V, W> {
    type DomainType;
    fn wrap(a: Self::DomainType) -> DomainElement<T, U, V, W>;
    fn try_unwrap(a: DomainElement<T, U, V, W>) -> Option<Self::DomainType>;
    #[inline(always)]
    fn unwrap(a: DomainElement<T, U, V, W>) -> Self::DomainType {
        Self::try_unwrap(a).unwrap_or_else(|| panic!("Can't unwrap DomainElement, wrong type"))
    }
}

impl<T, U, V, W> Domain<T, U, V, W> for bool {
    type DomainType = T;

    #[inline(always)]
    fn wrap(a: Self::DomainType) -> DomainElement<T, U, V, W> {
        DomainElement::Bit(a)
    }

    #[inline(always)]
    fn try_unwrap(a: DomainElement<T, U, V, W>) -> Option<Self::DomainType> {
        match a {
            DomainElement::Bit(b) => Some(b),
            DomainElement::Scalar(_) => None,
            DomainElement::Base(_) => None,
            DomainElement::Curve(_) => None,
        }
    }
}

impl<T, U, V, W> Domain<T, U, V, W> for ScalarField {
    type DomainType = U;

    #[inline(always)]
    fn wrap(a: Self::DomainType) -> DomainElement<T, U, V, W> {
        DomainElement::Scalar(a)
    }

    #[inline(always)]
    fn try_unwrap(a: DomainElement<T, U, V, W>) -> Option<Self::DomainType> {
        match a {
            DomainElement::Bit(_) => None,
            DomainElement::Scalar(x) => Some(x),
            DomainElement::Base(_) => None,
            DomainElement::Curve(_) => None,
        }
    }
}

impl<T, U, V, W> Domain<T, U, V, W> for CurvePoint {
    type DomainType = W;

    fn wrap(a: Self::DomainType) -> DomainElement<T, U, V, W> {
        DomainElement::Curve(a)
    }

    fn try_unwrap(a: DomainElement<T, U, V, W>) -> Option<Self::DomainType> {
        match a {
            DomainElement::Bit(_) => None,
            DomainElement::Scalar(_) => None,
            DomainElement::Base(_) => None,
            DomainElement::Curve(x) => Some(x),
        }
    }
}

impl<T, U, V, W> Domain<T, U, V, W> for BaseField {
    type DomainType = V;

    fn wrap(a: Self::DomainType) -> DomainElement<T, U, V, W> {
        DomainElement::Base(a)
    }

    fn try_unwrap(a: DomainElement<T, U, V, W>) -> Option<Self::DomainType> {
        match a {
            DomainElement::Bit(_) => None,
            DomainElement::Scalar(_) => None,
            DomainElement::Base(x) => Some(x),
            DomainElement::Curve(_) => None,
        }
    }
}