arcium-core-utils 0.8.1

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
127
128
129
130
131
132
133

use primitives::{
    algebra::elliptic_curve::{Curve, Point, Scalar},
    types::PeerNumber,
};
use serde::Deserialize;
#[cfg(test)]
use serde::Serialize;

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

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

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

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

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

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

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

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

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

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

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

impl TryFrom<FieldPlaintextUnaryOp> for latest::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 latest::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)]
#[cfg_attr(test, derive(Serialize))]
#[serde(bound(
    deserialize = "Scalar<C>: Deserialize<'de>, Point<C>: Deserialize<'de>",
    serialize = "Scalar<C>: Serialize, Point<C>: Serialize"
))]
#[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)]
#[cfg_attr(test, derive(Serialize))]
#[repr(C)]
pub enum Batched {
    Yes(usize),
    No,
}

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