Struct fancy_garbling::circuit::CircuitBuilder

pub struct CircuitBuilder { /* fields omitted */ }

CircuitBuilder is used to build circuits.

Methods

impl CircuitBuilder

pub fn new() -> Self

Make a new CircuitBuilder.

pub fn finish(self) -> Circuit

Finish circuit building, outputting the resulting circuit.

pub fn garbler_input(&mut self, modulus: u16) -> CircuitRef

Get CircuitRef for a garbler input wire.

pub fn evaluator_input(&mut self, modulus: u16) -> CircuitRef

Get CircuitRef for an evaluator input wire.

pub fn garbler_inputs(&mut self, mods: &[u16]) -> Vec<CircuitRef>

Get a vec of CircuitRefs for garbler inputs.

pub fn evaluator_inputs(&mut self, mods: &[u16]) -> Vec<CircuitRef>

Get a vec of CircuitRefs for garbler inputs.

pub fn crt_garbler_input(&mut self, modulus: u128) -> CrtBundle<CircuitRef>

Get a CrtBundle for the garbler using composite modulus Q

pub fn crt_evaluator_input(&mut self, modulus: u128) -> CrtBundle<CircuitRef>

Get a CrtBundle for the evaluator using composite modulus Q

pub fn bin_garbler_input(&mut self, nbits: usize) -> BinaryBundle<CircuitRef>

Get a BinaryBundle for the garbler with n bits.

pub fn bin_evaluator_input(&mut self, nbits: usize) -> BinaryBundle<CircuitRef>

Get a BinaryBundle for the evaluator with n bits.

Trait Implementations

impl Fancy for CircuitBuilder

type Item = CircuitRef

The underlying wire datatype created by an object implementing Fancy.

type Error = CircuitBuilderError

Errors which may be thrown by the users of Fancy.

fn constant(
    &mut self,
    val: u16,
    modulus: u16
) -> Result<CircuitRef, Self::Error>

Create a constant x with modulus q.

fn add(
    &mut self,
    xref: &CircuitRef,
    yref: &CircuitRef
) -> Result<CircuitRef, Self::Error>

Add x and y.

fn sub(
    &mut self,
    xref: &CircuitRef,
    yref: &CircuitRef
) -> Result<CircuitRef, Self::Error>

Subtract x and y.

fn cmul(&mut self, xref: &CircuitRef, c: u16) -> Result<CircuitRef, Self::Error>

Multiply x times the constant c.

fn proj(
    &mut self,
    xref: &CircuitRef,
    output_modulus: u16,
    tt: Option<Vec<u16>>
) -> Result<CircuitRef, Self::Error>

Project x according to the truth table tt. Resulting wire has modulus q.

fn mul(
    &mut self,
    xref: &CircuitRef,
    yref: &CircuitRef
) -> Result<CircuitRef, Self::Error>

Multiply x and y.

fn output(&mut self, xref: &CircuitRef) -> Result<(), Self::Error>

Process this wire as output.

fn add_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Sum up a slice of wires.

fn xor(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Xor is just addition, with the requirement that x and y are mod 2.

fn negate(&mut self, x: &Self::Item) -> Result<Self::Item, Self::Error>

Negate by xoring x with 1.

fn and(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

And is just multiplication, with the requirement that x and y are mod 2.

fn or(
    &mut self,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

Or uses Demorgan's Rule implemented with multiplication and negation.

fn and_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if all wires equal 1.

fn or_many(&mut self, args: &[Self::Item]) -> Result<Self::Item, Self::Error>

Returns 1 if any wire equals 1.

fn mod_change(
    &mut self,
    x: &Self::Item,
    to_modulus: u16
) -> Result<Self::Item, Self::Error>

Change the modulus of x to to_modulus using a projection gate.

fn adder(
    &mut self,
    x: &Self::Item,
    y: &Self::Item,
    carry_in: Option<&Self::Item>
) -> Result<(Self::Item, Self::Item), Self::Error>

Binary adder. Returns the result and the carry.

fn mux(
    &mut self,
    b: &Self::Item,
    x: &Self::Item,
    y: &Self::Item
) -> Result<Self::Item, Self::Error>

If b = 0 returns x else y.

fn mux_constant_bits(
    &mut self,
    x: &Self::Item,
    b1: bool,
    b2: bool
) -> Result<Self::Item, Self::Error>

If x = 0 returns the constant b1 else return b2. Folds constants if possible.

fn outputs(&mut self, xs: &[Self::Item]) -> Result<(), Self::Error>

Output a slice of wires.