Struct CircuitBuilder 

pub struct CircuitBuilder<Circuit> { /* private fields */ }

CircuitBuilder is used to build circuits.

Implementations

impl<Circuit: CircuitType> CircuitBuilder<Circuit>

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<Circuit: CircuitType> Default for CircuitBuilder<Circuit>

fn default() -> Self

Returns the “default value” for a type.

impl<Circuit: CircuitType> Fancy for CircuitBuilder<Circuit>

type Item = CircuitRef

The underlying wire datatype created by an object implementing Fancy.

fn constant( &mut self, val: u16, modulus: u16, _: &mut Channel<'_>, ) -> Result<CircuitRef>

Create a constant x with modulus q.

fn output( &mut self, xref: &CircuitRef, _: &mut Channel<'_>, ) -> Result<Option<u16>>

Process this wire as output. Some Fancy implementers don’t actually return output, but they need to be involved in the process, so they can return None.

fn outputs( &mut self, xs: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Option<Vec<u16>>>

Output a slice of wires.

impl FancyArithmetic for CircuitBuilder<ArithmeticCircuit>

fn add(&mut self, xref: &CircuitRef, yref: &CircuitRef) -> CircuitRef

Add x and y.

fn sub(&mut self, xref: &CircuitRef, yref: &CircuitRef) -> CircuitRef

Subtract x and y.

fn cmul(&mut self, xref: &CircuitRef, c: u16) -> CircuitRef

Multiply x times the constant c.

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

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

fn mul( &mut self, xref: &CircuitRef, yref: &CircuitRef, _channel: &mut Channel<'_>, ) -> Result<CircuitRef>

Multiply x and y.

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

Sum up a slice of wires.

fn mod_change( &mut self, x: &Self::Item, to_modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

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

impl FancyBinary for CircuitBuilder<ArithmeticCircuit>

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

Binary Xor

fn and( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Binary And

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

Binary Not

fn or( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Uses Demorgan’s Rule implemented with an and gate and negation.

fn adder( &mut self, x: &Self::Item, y: &Self::Item, carry_in: Option<&Self::Item>, channel: &mut Channel<'_>, ) -> Result<(Self::Item, Self::Item)>

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Self::Item

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

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

fn mux( &mut self, b: &Self::Item, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If b = 0 returns x else y.

impl FancyBinary for CircuitBuilder<BinaryCircuit>

fn xor(&mut self, xref: &Self::Item, yref: &Self::Item) -> Self::Item

Binary Xor

fn negate(&mut self, xref: &Self::Item) -> Self::Item

Binary Not

fn and( &mut self, xref: &Self::Item, yref: &Self::Item, _: &mut Channel<'_>, ) -> Result<Self::Item>

Binary And

fn or( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Uses Demorgan’s Rule implemented with an and gate and negation.

fn adder( &mut self, x: &Self::Item, y: &Self::Item, carry_in: Option<&Self::Item>, channel: &mut Channel<'_>, ) -> Result<(Self::Item, Self::Item)>

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Self::Item

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

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

fn mux( &mut self, b: &Self::Item, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If b = 0 returns x else y.