Struct MpcFabric

pub struct MpcFabric { /* private fields */ }

A fabric for the MPC protocol, defines a dependency injection layer that dynamically schedules circuit gate evaluations onto the network to be executed

The fabric does not block on gate evaluations, but instead returns a handle to a future result that may be polled to obtain the materialized result. This allows the application layer to continue using the fabric, scheduling more gates to be evaluated and maximally exploiting gate-level parallelism within the circuit

Implementations

impl MpcFabric

pub fn new<N: 'static + MpcNetwork, S: 'static + SharedValueSource>( network: N, beaver_source: S, ) -> Self

Constructor

pub fn new_with_size_hint<N: 'static + MpcNetwork, S: 'static + SharedValueSource>( size_hint: usize, network: N, beaver_source: S, ) -> Self

Constructor that takes an additional size hint, indicating how much buffer space the fabric should allocate for results. The size is given in number of gates

pub fn party_id(&self) -> PartyId

Get the party ID of the local party

pub fn shutdown(self)

Shutdown the fabric and the threads it has spawned

pub fn register_waiter(&self, waiter: ResultWaiter)

Register a waiter on a result

pub fn zero(&self) -> ScalarResult

Get the hardcoded zero wire as a raw ScalarResult

pub fn zero_authenticated(&self) -> AuthenticatedScalarResult

Get the hardcoded zero wire as an AuthenticatedScalarResult

Both parties hold the share 0 directly in this case

pub fn zeros_authenticated(&self, n: usize) -> Vec<AuthenticatedScalarResult>

Get a batch of references to the zero wire as an AuthenticatedScalarResult

pub fn one(&self) -> ScalarResult

Get the hardcoded one wire as a raw ScalarResult

pub fn one_authenticated(&self) -> AuthenticatedScalarResult

Get the hardcoded one wire as an AuthenticatedScalarResult

Party 0 holds the value zero and party 1 holds the value one

pub fn ones_authenticated(&self, n: usize) -> Vec<AuthenticatedScalarResult>

Get a batch of references to the one wire as an AuthenticatedScalarResult

pub fn curve_identity(&self) -> ResultHandle<StarkPoint>

Get the hardcoded curve identity wire as a raw StarkPoint

pub fn curve_identity_authenticated(&self) -> AuthenticatedStarkPointResult

Get the hardcoded curve identity wire as an AuthenticatedStarkPointResult

Both parties hold the identity point directly in this case

pub fn share_scalar<T: Into<Scalar>>( &self, val: T, sender: PartyId, ) -> AuthenticatedScalarResult

Share a Scalar value with the counterparty

pub fn batch_share_scalar<T: Into<Scalar>>( &self, vals: Vec<T>, sender: PartyId, ) -> Vec<AuthenticatedScalarResult>

Share a batch of Scalar values with the counterparty

pub fn share_point( &self, val: StarkPoint, sender: PartyId, ) -> AuthenticatedStarkPointResult

Share a StarkPoint value with the counterparty

pub fn batch_share_point( &self, vals: Vec<StarkPoint>, sender: PartyId, ) -> Vec<AuthenticatedStarkPointResult>

Share a batch of StarkPoints with the counterparty

pub fn allocate_scalar<T: Into<Scalar>>(&self, value: T) -> ResultHandle<Scalar>

Allocate a public value in the fabric

pub fn allocate_scalars<T: Into<Scalar>>( &self, values: Vec<T>, ) -> Vec<ResultHandle<Scalar>>

Allocate a batch of scalars in the fabric

pub fn allocate_preshared_scalar<T: Into<Scalar>>( &self, value: T, ) -> AuthenticatedScalarResult

Allocate a scalar as a secret share of an already shared value

pub fn batch_allocate_preshared_scalar<T: Into<Scalar>>( &self, values: Vec<T>, ) -> Vec<AuthenticatedScalarResult>

Allocate a batch of scalars as secret shares of already shared values

pub fn allocate_point(&self, value: StarkPoint) -> ResultHandle<StarkPoint>

Allocate a public curve point in the fabric

pub fn allocate_points( &self, values: Vec<StarkPoint>, ) -> Vec<ResultHandle<StarkPoint>>

Allocate a batch of points in the fabric

pub fn send_value<T: From<ResultValue> + Into<NetworkPayload>>( &self, value: ResultHandle<T>, ) -> ResultHandle<T>

Send a value to the peer, placing the identity in the local result buffer at the send ID

pub fn send_values<T>(&self, values: &[ResultHandle<T>]) -> ResultHandle<Vec<T>>

where T: From<ResultValue>, Vec<T>: Into<NetworkPayload> + From<ResultValue>,

Send a batch of values to the counterparty

pub fn receive_value<T: From<ResultValue>>(&self) -> ResultHandle<T>

Receive a value from the peer

pub fn exchange_value<T: From<ResultValue> + Into<NetworkPayload>>( &self, value: ResultHandle<T>, ) -> ResultHandle<T>

Exchange a value with the peer, i.e. send then receive or receive then send based on the party ID

Returns a handle to the received value, which will be different for different parties

pub fn exchange_values<T>( &self, values: &[ResultHandle<T>], ) -> ResultHandle<Vec<T>>

where T: From<ResultValue>, Vec<T>: From<ResultValue> + Into<NetworkPayload>,

Exchange a batch of values with the peer, i.e. send then receive or receive then send based on party ID

pub fn share_plaintext<T>(&self, value: T, sender: PartyId) -> ResultHandle<T>

where T: 'static + From<ResultValue> + Into<NetworkPayload> + Send + Sync,

Share a public value with the counterparty

pub fn batch_share_plaintext<T>( &self, values: Vec<T>, sender: PartyId, ) -> ResultHandle<Vec<T>>

where T: 'static + From<ResultValue> + Send + Sync, Vec<T>: Into<NetworkPayload> + From<ResultValue>,

Share a batch of public values with the counterparty

pub fn new_gate_op<F, T>( &self, args: Vec<ResultId>, function: F, ) -> ResultHandle<T>

where F: 'static + FnOnce(Vec<ResultValue>) -> ResultValue + Send + Sync, T: From<ResultValue>,

Construct a new gate operation in the fabric, i.e. one that can be evaluated immediate given its inputs

pub fn new_batch_gate_op<F, T>( &self, args: Vec<ResultId>, output_arity: usize, function: F, ) -> Vec<ResultHandle<T>>

where F: 'static + FnOnce(Vec<ResultValue>) -> Vec<ResultValue> + Send + Sync, T: From<ResultValue>,

Construct a new batch gate operation in the fabric, i.e. one that can be evaluated to return an array of results

The array must be sized so that the fabric knows how many results to allocate buffer space for ahead of execution

pub fn new_network_op<F, T>( &self, args: Vec<ResultId>, function: F, ) -> ResultHandle<T>

where F: 'static + FnOnce(Vec<ResultValue>) -> NetworkPayload + Send + Sync, T: From<ResultValue>,

Construct a new network operation in the fabric, i.e. one that requires a value to be sent over the channel

pub fn next_beaver_triple( &self, ) -> (MpcScalarResult, MpcScalarResult, MpcScalarResult)

Sample the next beaver triplet from the beaver source

pub fn next_beaver_triple_batch( &self, n: usize, ) -> (Vec<MpcScalarResult>, Vec<MpcScalarResult>, Vec<MpcScalarResult>)

Sample a batch of beaver triples

pub fn next_authenticated_triple( &self, ) -> (AuthenticatedScalarResult, AuthenticatedScalarResult, AuthenticatedScalarResult)

Sample the next beaver triplet with MACs from the beaver source

TODO: Authenticate these values either here or in the pre-processing phase as per the SPDZ paper

pub fn next_authenticated_triple_batch( &self, n: usize, ) -> (Vec<AuthenticatedScalarResult>, Vec<AuthenticatedScalarResult>, Vec<AuthenticatedScalarResult>)

Sample the next batch of beaver triples as AuthenticatedScalars

pub fn random_shared_scalars(&self, n: usize) -> Vec<ScalarResult>

Sample a batch of random shared values from the beaver source

pub fn random_shared_scalars_authenticated( &self, n: usize, ) -> Vec<AuthenticatedScalarResult>

Sample a batch of random shared values from the beaver source and allocate them as AuthenticatedScalars

pub fn random_inverse_pair( &self, ) -> (AuthenticatedScalarResult, AuthenticatedScalarResult)

Sample a pair of values that are multiplicative inverses of one another

pub fn random_inverse_pairs( &self, n: usize, ) -> (Vec<AuthenticatedScalarResult>, Vec<AuthenticatedScalarResult>)

Sample a batch of values that are multiplicative inverses of one another

pub fn random_shared_bit(&self) -> AuthenticatedScalarResult

Sample a random shared bit from the beaver source

pub fn random_shared_bits(&self, n: usize) -> Vec<AuthenticatedScalarResult>

Sample a batch of random shared bits from the beaver source

Trait Implementations

impl Clone for MpcFabric

fn clone(&self) -> MpcFabric

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MpcFabric

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

Formats the value using the given formatter.