Struct prio::vdaf::prio2::Prio2

pub struct Prio2 { /* private fields */ }

Available on crate features crypto-dependencies and experimental only.

The Prio2 VDAF. It supports the same measurement type as Prio3SumVec with bits == 1 but uses the proof system and finite field deployed in ENPA.

Implementations

impl Prio2

pub fn new(input_len: usize) -> Result<Self, VdafError>

Returns an instance of the VDAF for the given input length.

pub fn prepare_init_with_query_rand( &self, query_rand: FieldPrio2, input_share: &Share<FieldPrio2, 32>, is_leader: bool ) -> Result<(Prio2PrepareState, Prio2PrepareShare), VdafError>

Prepare an input share for aggregation using the given field element query_rand to compute the verifier share.

In the Aggregator trait implementation for Prio2, the query randomness is computed jointly by the Aggregators. This method is designed to be used in applications, like ENPA, in which the query randomness is instead chosen by a third-party.

Trait Implementations

impl Aggregator<32, 16> for Prio2

type PrepareState = Prio2PrepareState

State of the Aggregator during the Prepare process.

type PrepareShare = Prio2PrepareShare

The type of messages sent by each aggregator at each round of the Prepare Process.

type PrepareMessage = ()

Result of preprocessing a round of preparation shares. This is used by all aggregators as an input to the next round of the Prepare Process.

fn prepare_init( &self, agg_key: &[u8; 32], agg_id: usize, _agg_param: &Self::AggregationParam, nonce: &[u8; 16], _public_share: &Self::PublicShare, input_share: &Share<FieldPrio2, 32> ) -> Result<(Prio2PrepareState, Prio2PrepareShare), VdafError>

Begins the Prepare process with the other Aggregators. The Self::PrepareState returned is passed to Self::prepare_next to get this aggregator’s first-round prepare message.

fn prepare_shares_to_prepare_message<M: IntoIterator<Item = Prio2PrepareShare>>( &self, _: &Self::AggregationParam, inputs: M ) -> Result<(), VdafError>

Preprocess a round of preparation shares into a single input to Self::prepare_next.

fn prepare_next( &self, state: Prio2PrepareState, _input: () ) -> Result<PrepareTransition<Self, 32, 16>, VdafError>

Compute the next state transition from the current state and the previous round of input messages. If this returns PrepareTransition::Continue, then the returned Self::PrepareShare should be combined with the other Aggregators’ PrepareShares from this round and passed into another call to this method. This continues until this method returns PrepareTransition::Finish, at which point the returned output share may be aggregated. If the method returns an error, the aggregator should consider its input share invalid and not attempt to process it any further.

fn aggregate<M: IntoIterator<Item = OutputShare<FieldPrio2>>>( &self, _agg_param: &Self::AggregationParam, out_shares: M ) -> Result<AggregateShare<FieldPrio2>, VdafError>

Aggregates a sequence of output shares into an aggregate share.

impl Client<16> for Prio2

fn shard( &self, measurement: &Vec<u32>, _nonce: &[u8; 16] ) -> Result<(Self::PublicShare, Vec<Share<FieldPrio2, 32>>), VdafError>

Shards a measurement into a public share and a sequence of input shares, one for each Aggregator.

impl Clone for Prio2

fn clone(&self) -> Prio2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Collector for Prio2

fn unshard<M: IntoIterator<Item = AggregateShare<FieldPrio2>>>( &self, _agg_param: &Self::AggregationParam, agg_shares: M, _num_measurements: usize ) -> Result<Vec<u32>, VdafError>

Combines aggregate shares into the aggregate result.

impl Debug for Prio2

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

Formats the value using the given formatter.

impl Vdaf for Prio2

type Measurement = Vec<u32>

The type of Client measurement to be aggregated.

type AggregateResult = Vec<u32>

The aggregate result of the VDAF execution.

type AggregationParam = ()

The aggregation parameter, used by the Aggregators to map their input shares to output shares.

type PublicShare = ()

A public share sent by a Client.

type InputShare = Share<FieldPrio2, 32>

An input share sent by a Client.

type OutputShare = OutputShare<FieldPrio2>

An output share recovered from an input share by an Aggregator.

type AggregateShare = AggregateShare<FieldPrio2>

An Aggregator’s share of the aggregate result.

fn algorithm_id(&self) -> u32

Return the VDAF’s algorithm ID.

fn num_aggregators(&self) -> usize

The number of Aggregators. The Client generates as many input shares as there are Aggregators.

fn domain_separation_tag(&self, usage: u16) -> [u8; 8]

Generate the domain separation tag for this VDAF. The output is used for domain separation by the XOF.