arcium-core-utils 0.4.5

Arcium core utils
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

use primitives::{
    algebra::elliptic_curve::{Curve, Point, Scalar},
    types::PeerNumber,
};
use serde::Deserialize;

use crate::circuit::{
    v1::{
        constants::{
            BaseFieldPlaintext,
            BaseFieldPlaintextBatch,
            BitPlaintext,
            BitPlaintextBatch,
            Mersenne107Plaintext,
            Mersenne107PlaintextBatch,
            PointPlaintext,
            PointPlaintextBatch,
            ScalarPlaintext,
            ScalarPlaintextBatch,
        },
        errors::OpsConversionError,
        AlgebraicType,
    },
    v2,
};

/// Enum representing unary operations on field element plaintexts.
pub type FieldPlaintextUnaryOp = v2::FieldPlaintextUnaryOp;

/// Enum representing binary operations on field element plaintexts.
pub type FieldPlaintextBinaryOp = v2::FieldPlaintextBinaryOp;

/// Enum representing unary operations on a field share.
pub type FieldShareUnaryOp = v2::FieldShareUnaryOp;

/// Enum representing binary operations on field shares. This includes the case where the second
/// operand is a plaintext value.
pub type FieldShareBinaryOp = v2::FieldShareBinaryOp;

/// Enum representing unary operations on binary shares
pub type BitShareUnaryOp = v2::BitShareUnaryOp;

/// Enum representing binary operations on binary shares.
pub type BitShareBinaryOp = v2::BitShareBinaryOp;

/// Enum representing unary operations on plaintext points.
pub type PointPlaintextUnaryOp = v2::PointPlaintextUnaryOp;

/// Enum representing binary operations on plaintext points/scalars.
pub type PointPlaintextBinaryOp = v2::PointPlaintextBinaryOp;

/// Enum representing unary operations on point shares.
pub type PointShareUnaryOp = v2::PointShareUnaryOp;

/// Enum representing binary operations on point shares.
pub type PointShareBinaryOp = v2::PointShareBinaryOp;

impl TryFrom<FieldPlaintextUnaryOp> for v2::BitPlaintextUnaryOp {
    type Error = OpsConversionError;

    fn try_from(value: FieldPlaintextUnaryOp) -> Result<Self, Self::Error> {
        match value {
            FieldPlaintextUnaryOp::Neg => Ok(Self::Not),
            _ => Err(OpsConversionError::PlaintextUnaryOpFieldToBit(value)),
        }
    }
}

impl TryFrom<FieldPlaintextBinaryOp> for v2::BitPlaintextBinaryOp {
    type Error = OpsConversionError;

    fn try_from(value: FieldPlaintextBinaryOp) -> Result<Self, Self::Error> {
        match value {
            FieldPlaintextBinaryOp::Mul => Ok(Self::And),
            FieldPlaintextBinaryOp::Xor => Ok(Self::Xor),
            FieldPlaintextBinaryOp::Or => Ok(Self::Or),
            _ => Err(OpsConversionError::PlaintextBinaryOpFieldToBit(value)),
        }
    }
}

#[derive(Deserialize)]
#[serde(bound(deserialize = "Scalar<C>: Deserialize<'de>, Point<C>: Deserialize<'de>"))]
#[repr(C)]
pub enum Input<C: Curve> {
    SecretPlaintext {
        inputer: PeerNumber,
        algebraic_type: AlgebraicType,
        batched: Batched,
    },
    Share {
        algebraic_type: AlgebraicType,
        batched: Batched,
    },
    RandomShare {
        algebraic_type: AlgebraicType,
        batched: Batched,
    },
    Scalar(ScalarPlaintext<C>),
    ScalarBatch(ScalarPlaintextBatch<C>),
    BaseField(BaseFieldPlaintext<C>),
    BaseFieldBatch(BaseFieldPlaintextBatch<C>),
    Mersenne107(Mersenne107Plaintext),
    Mersenne107Batch(Mersenne107PlaintextBatch),
    Bit(BitPlaintext),
    BitBatch(BitPlaintextBatch),
    Point(PointPlaintext<C>),
    PointBatch(PointPlaintextBatch<C>),
}

/// Enum representing whether a gate is batched or not.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize)]
#[repr(C)]
pub enum Batched {
    Yes(usize),
    No,
}

impl Batched {
    pub fn count(&self) -> usize {
        match self {
            Batched::Yes(count) => *count,
            Batched::No => 1,
        }
    }
}