arcium-core-utils 0.8.0

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

use primitives::algebra::{
    elliptic_curve::{BaseFieldElement, Curve, Point, Scalar},
    field::{mersenne::Mersenne107, subfield_element::Mersenne107Element, Bit},
};
use serde::{Deserialize, Serialize};

use crate::{
    circuit::{latest, old::legacy_codec::legacy},
    config::MpcConfig,
};

pub type FieldPlaintextUnaryOp = latest::FieldPlaintextUnaryOp;
pub type FieldPlaintextBinaryOp = latest::FieldPlaintextBinaryOp;
pub type FieldShareUnaryOp = latest::FieldShareUnaryOp;
pub type FieldShareBinaryOp = latest::FieldShareBinaryOp;
pub type BitShareUnaryOp = latest::BitShareUnaryOp;
pub type BitShareBinaryOp = latest::BitShareBinaryOp;
pub type BitPlaintextUnaryOp = latest::BitPlaintextUnaryOp;
pub type BitPlaintextBinaryOp = latest::BitPlaintextBinaryOp;
pub type PointPlaintextUnaryOp = latest::PointPlaintextUnaryOp;
pub type PointPlaintextBinaryOp = latest::PointPlaintextBinaryOp;
pub type PointShareUnaryOp = latest::PointShareUnaryOp;
pub type PointShareBinaryOp = latest::PointShareBinaryOp;
pub type Input = latest::Input;

/// Constant payloads keep their pre-#748 `serde_bytes` encoding -- see [`legacy`].
#[derive(Serialize, Deserialize)]
#[repr(C)]
pub enum Constant<C: Curve> {
    Scalar(#[serde(with = "legacy")] Scalar<C>),
    ScalarBatch(#[serde(with = "legacy")] Vec<Scalar<C>>),
    BaseField(#[serde(with = "legacy")] BaseFieldElement<C>),
    BaseFieldBatch(#[serde(with = "legacy")] Vec<BaseFieldElement<C>>),
    Mersenne107(#[serde(with = "legacy")] Mersenne107Element),
    Mersenne107Batch(#[serde(with = "legacy")] Vec<Mersenne107Element>),
    Bit(#[serde(with = "legacy")] Bit),
    BitBatch(#[serde(with = "legacy")] Vec<Bit>),
    Point(#[serde(with = "legacy")] Point<C>),
    PointBatch(#[serde(with = "legacy")] Vec<Point<C>>),
}

impl<C: Curve, Cfg: MpcConfig<Curve = C, Field = Mersenne107>> From<Constant<C>>
    for latest::Constant<Cfg>
{
    fn from(value: Constant<C>) -> Self {
        match value {
            Constant::Scalar(value) => latest::Constant::Scalar(value),
            Constant::ScalarBatch(value) => latest::Constant::ScalarBatch(value),
            Constant::BaseField(value) => latest::Constant::BaseField(value),
            Constant::BaseFieldBatch(value) => latest::Constant::BaseFieldBatch(value),
            Constant::Mersenne107(value) => latest::Constant::MpcField(value),
            Constant::Mersenne107Batch(value) => latest::Constant::MpcFieldBatch(value),
            Constant::Bit(value) => latest::Constant::Bit(value),
            Constant::BitBatch(value) => latest::Constant::BitBatch(value),
            Constant::Point(value) => latest::Constant::Point(value),
            Constant::PointBatch(value) => latest::Constant::PointBatch(value),
        }
    }
}