Enum Gate 

#[repr(C)]
pub enum Gate<C: MpcConfig> {
    Input(Input),
    Constant(Constant<C>),
    Random {
        algebraic_type: AlgebraicType,
        batch_size: BatchSize,
    },
    FieldShareUnaryOp {
        x: GateIndex,
        op: FieldShareUnaryOp,
    },
    FieldShareBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: FieldShareBinaryOp,
    },
    BatchSummation {
        x: GateIndex,
    },
    BitShareUnaryOp {
        x: GateIndex,
        op: BitShareUnaryOp,
    },
    BitShareBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: BitShareBinaryOp,
    },
    PointShareUnaryOp {
        p: GateIndex,
        op: PointShareUnaryOp,
    },
    PointShareBinaryOp {
        p: GateIndex,
        y: GateIndex,
        op: PointShareBinaryOp,
    },
    FieldPlaintextUnaryOp {
        x: GateIndex,
        op: FieldPlaintextUnaryOp,
    },
    FieldPlaintextBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: FieldPlaintextBinaryOp,
    },
    BitPlaintextUnaryOp {
        x: GateIndex,
        op: BitPlaintextUnaryOp,
    },
    BitPlaintextBinaryOp {
        x: GateIndex,
        y: GateIndex,
        op: BitPlaintextBinaryOp,
    },
    PointPlaintextUnaryOp {
        p: GateIndex,
        op: PointPlaintextUnaryOp,
    },
    PointPlaintextBinaryOp {
        p: GateIndex,
        y: GateIndex,
        op: PointPlaintextBinaryOp,
    },
    DaBit {
        field_type: FieldType,
        batch_size: BatchSize,
    },
    GetDaBitFieldShare {
        x: GateIndex,
    },
    GetDaBitSharedBit {
        x: GateIndex,
    },
    BaseFieldPow {
        x: GateIndex,
        exp: BoxedUint,
    },
    BitPlaintextToField {
        x: GateIndex,
        field_type: FieldType,
    },
    FieldPlaintextToBit {
        x: GateIndex,
    },
    ExtractFromBatch {
        x: GateIndex,
        slice: Slice,
    },
    CollectToBatch {
        wires: Vec<GateIndex>,
    },
    PointFromPlaintextCoordinates {
        wires: Vec<GateIndex>,
    },
    PlaintextPointToCoordinates {
        point: GateIndex,
    },
    PlaintextKeccakF1600 {
        x: GateIndex,
    },
    CompressPlaintextPoint {
        point: GateIndex,
    },
    KeyRecoveryPlaintextComputeErrors {
        d_minus_one: GateIndex,
        syndromes: GateIndex,
    },
    AesGcmKeyStream {
        round_keys: GateIndex,
        iv: GateIndex,
        n_ciphertext_blocks: u32,
    },
    GhashPowersOfH {
        h: GateIndex,
        n_ciphertext_blocks: u32,
    },
    Ghash {
        x: GateIndex,
        powers_of_h: GateIndex,
    },
    AesKeySchedule {
        key: GateIndex,
    },
    ConstrainPlaintextBits {
        x: GateIndex,
        clauses: Vec<ConstraintClause>,
        on_ambiguity: OnAmbiguity,
    },
}

Gate operations, where the operation arguments correspond to wire label.

Variants

Input(Input)

Input a wire

Constant(Constant<C>)

Input a constant value

Random

Generate random shares

Fields

algebraic_type: AlgebraicType

batch_size: BatchSize

FieldShareUnaryOp

Field share unary operations

Fields

x: GateIndex

op: FieldShareUnaryOp

FieldShareBinaryOp

Field share binary operations, where the second wire may be a plaintext.

Fields

x: GateIndex

y: GateIndex

op: FieldShareBinaryOp

BatchSummation

Fields

x: GateIndex

BitShareUnaryOp

Fields

x: GateIndex

op: BitShareUnaryOp

BitShareBinaryOp

Fields

x: GateIndex

y: GateIndex

op: BitShareBinaryOp

PointShareUnaryOp

Operations with elliptic curve points

Fields

p: GateIndex

op: PointShareUnaryOp

PointShareBinaryOp

Fields

p: GateIndex

y: GateIndex

op: PointShareBinaryOp

FieldPlaintextUnaryOp

Field plaintext unary operations

Fields

x: GateIndex

op: FieldPlaintextUnaryOp

FieldPlaintextBinaryOp

Field plaintext binary operations

Fields

x: GateIndex

y: GateIndex

op: FieldPlaintextBinaryOp

BitPlaintextUnaryOp

Fields

x: GateIndex

op: BitPlaintextUnaryOp

BitPlaintextBinaryOp

Fields

x: GateIndex

y: GateIndex

op: BitPlaintextBinaryOp

PointPlaintextUnaryOp

Fields

p: GateIndex

op: PointPlaintextUnaryOp

PointPlaintextBinaryOp

Fields

p: GateIndex

y: GateIndex

op: PointPlaintextBinaryOp

DaBit

Request a daBit

Fields

field_type: FieldType

batch_size: BatchSize

GetDaBitFieldShare

Fields

x: GateIndex

GetDaBitSharedBit

Fields

x: GateIndex

BaseFieldPow

Base field exponentiation operation

Fields

x: GateIndex

exp: BoxedUint

BitPlaintextToField

Bit plaintext conversion operations

Fields

x: GateIndex

field_type: FieldType

FieldPlaintextToBit

Fields

x: GateIndex

ExtractFromBatch

Get a slice of elements from a batched wire

Fields

x: GateIndex

slice: Slice

CollectToBatch

Fields

wires: Vec<GateIndex>

PointFromPlaintextCoordinates

Fields

wires: Vec<GateIndex>

PlaintextPointToCoordinates

Fields

point: GateIndex

PlaintextKeccakF1600

Fields

x: GateIndex

CompressPlaintextPoint

Fields

point: GateIndex

KeyRecoveryPlaintextComputeErrors

Fields

d_minus_one: GateIndex

syndromes: GateIndex

AesGcmKeyStream

Fields

round_keys: GateIndex

iv: GateIndex

n_ciphertext_blocks: u32

GhashPowersOfH

Fields

h: GateIndex

n_ciphertext_blocks: u32

Ghash

Fields

x: GateIndex

powers_of_h: GateIndex

AesKeySchedule

Fields

key: GateIndex

ConstrainPlaintextBits

Plaintext bits that each peer supplies locally rather than reading from the agreed public inputs — a URL response, say — together with the constraints they must satisfy.

Outputs x.batch_size + 1 bits: the reconciled data, then a success bit. When no candidate satisfies any clause the data bits are all zero and the success bit is false, so the gate is total — every input has an output, and that output is the same on every peer. Failing this way rather than aborting is also what lets the gate be exercised by randomised tests, which would otherwise abort before reaching anything downstream.

Because peers fetch independently, they may start from different bits: a URL can serve different data to different peers, or fail to answer some of them. Reconciling that is the task’s job, not the gate’s; the gate only records what the bits must satisfy. Every constraint is a deterministic predicate over plaintext, so no secure computation is involved and constraints may be arbitrarily expensive.

clauses is a disjunctive normal form: the bits are acceptable when some clause holds, and a clause holds when all of its constraints do. The slices in a clause index into x, and each clause must cover x on its own — a bit the satisfied clause does not mention has nothing to pin it down when peers disagree.

Fields

x: GateIndex

clauses: Vec<ConstraintClause>

on_ambiguity: OnAmbiguity

What to do when the satisfying candidates are not all the same batch. Does not affect the gate’s shape: the output is x.batch_size + 1 bits either way.

Implementations

impl<C: MpcConfig> Gate<C>

pub fn is_input(&self) -> bool

Check whether the gate is an input gate.

pub fn get_inputs(&self) -> Vec<GateIndex>

Returns the indices of gate inputs.

pub fn map_inputs<F: FnMut(GateIndex) -> GateIndex>(self, f: F) -> Self

Maps inplace gate inputs using the given function.

pub fn try_replace_inputs( self, inputs: Vec<GateIndex>, ) -> Result<Self, CircuitError<C>>

Tries to replace the gate inputs with the given ones.

This function returns an error if the number of given inputs does not match the number of gate inputs.

Trait Implementations

impl<C: Clone + MpcConfig> Clone for Gate<C>

fn clone(&self) -> Gate<C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: Debug + MpcConfig> Debug for Gate<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, C: MpcConfig> Deserialize<'de> for Gate<C>

where Scalar<C::Curve>: Deserialize<'de>, Point<C::Curve>: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: Eq + MpcConfig> Eq for Gate<C>

impl<C: Hash + MpcConfig> Hash for Gate<C>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<C: PartialEq + MpcConfig> PartialEq for Gate<C>

fn eq(&self, other: &Gate<C>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<C: MpcConfig> Serialize for Gate<C>

where Scalar<C::Curve>: Serialize, Point<C::Curve>: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C: PartialEq + MpcConfig> StructuralPartialEq for Gate<C>