Trait vb_accumulator::positive::Accumulator

pub trait Accumulator<E: Pairing> {
    // Required methods
    fn value(&self) -> &E::G1Affine;
    fn from_accumulated(accumulated: E::G1Affine) -> Self;

    // Provided methods
    fn check_before_add(
        &self,
        element: &E::ScalarField,
        state: &dyn State<E::ScalarField>
    ) -> Result<(), VBAccumulatorError> { ... }
    fn check_before_remove(
        &self,
        element: &E::ScalarField,
        state: &dyn State<E::ScalarField>
    ) -> Result<(), VBAccumulatorError> { ... }
    fn _compute_new_post_add(
        &self,
        element: &E::ScalarField,
        sk: &SecretKey<E::ScalarField>
    ) -> (E::ScalarField, E::G1Affine) { ... }
    fn _add(
        &self,
        element: E::ScalarField,
        sk: &SecretKey<E::ScalarField>,
        state: &mut dyn State<E::ScalarField>
    ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError> { ... }
    fn _compute_new_post_add_batch(
        &self,
        elements: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>
    ) -> (E::ScalarField, E::G1Affine) { ... }
    fn _add_batch(
        &self,
        elements: Vec<E::ScalarField>,
        sk: &SecretKey<E::ScalarField>,
        state: &mut dyn State<E::ScalarField>
    ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError> { ... }
    fn _compute_new_post_remove(
        &self,
        element: &E::ScalarField,
        sk: &SecretKey<E::ScalarField>
    ) -> (E::ScalarField, E::G1Affine) { ... }
    fn _remove(
        &self,
        element: &E::ScalarField,
        sk: &SecretKey<E::ScalarField>,
        state: &mut dyn State<E::ScalarField>
    ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError> { ... }
    fn _compute_new_post_remove_batch(
        &self,
        elements: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>
    ) -> (E::ScalarField, E::G1Affine) { ... }
    fn _remove_batch(
        &self,
        elements: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>,
        state: &mut dyn State<E::ScalarField>
    ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError> { ... }
    fn _compute_new_post_batch_updates(
        &self,
        additions: &[E::ScalarField],
        removals: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>
    ) -> (E::ScalarField, E::G1Affine) { ... }
    fn _batch_updates(
        &self,
        additions: Vec<E::ScalarField>,
        removals: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>,
        state: &mut dyn State<E::ScalarField>
    ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError> { ... }
    fn compute_membership_witness(
        &self,
        member: &E::ScalarField,
        sk: &SecretKey<E::ScalarField>
    ) -> MembershipWitness<E::G1Affine> { ... }
    fn get_membership_witness(
        &self,
        member: &E::ScalarField,
        sk: &SecretKey<E::ScalarField>,
        state: &dyn State<E::ScalarField>
    ) -> Result<MembershipWitness<E::G1Affine>, VBAccumulatorError> { ... }
    fn compute_membership_witnesses_for_batch(
        &self,
        members: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>
    ) -> Vec<MembershipWitness<E::G1Affine>> { ... }
    fn get_membership_witnesses_for_batch(
        &self,
        members: &[E::ScalarField],
        sk: &SecretKey<E::ScalarField>,
        state: &dyn State<E::ScalarField>
    ) -> Result<Vec<MembershipWitness<E::G1Affine>>, VBAccumulatorError> { ... }
    fn verify_membership_given_accumulated(
        V: &E::G1Affine,
        member: &E::ScalarField,
        witness: &MembershipWitness<E::G1Affine>,
        pk: &PublicKey<E>,
        params: &SetupParams<E>
    ) -> bool { ... }
    fn verify_membership(
        &self,
        member: &E::ScalarField,
        witness: &MembershipWitness<E::G1Affine>,
        pk: &PublicKey<E>,
        params: &SetupParams<E>
    ) -> bool { ... }
    fn randomized_value(&self, randomizer: &E::ScalarField) -> E::G1Affine { ... }
}

Trait to hold common functionality among both positive and universal accumulator Methods changing or reading accumulator state take a mutable or immutable reference to State which is a trait that should be implemented by a persistent database that tracks the accumulator’s members. Methods starting with compute_ (or _compute_ for common logic between Positive and Universal accumulator) do not depend on State and contain the logic only for that operation. This is useful when it is not possible to make the persistent database available to this code like when writing a WASM wrapper or when the persistent database cannot be made to satisfy one or functions of the trait State. Eg. function _add is used when adding a new element to the accumulator, it checks if the new element is not already part of the State and if not, computes the new accumulator and adds the element to the State; but the function _compute_new_post_add only computes the new accumulator, it does not modify (check or add) the State and hence does not need the reference to it. However, note that it is important to do the required checks and updates in State, eg. just by using _compute_new_post_add, a membership witness can be created for an element not present in the accumulator that will satisfy the verification (pairing) equation and thus make verify_membership return true. Thus, before creating a membership witness, State should be checked.

Required Methods

fn value(&self) -> &E::G1Affine

The accumulated value of all the members. It is considered a digest of state of the accumulator

fn from_accumulated(accumulated: E::G1Affine) -> Self

Create an Accumulator using the accumulated value. This is used for membership verification purposes only

Provided Methods

fn check_before_add( &self, element: &E::ScalarField, state: &dyn State<E::ScalarField> ) -> Result<(), VBAccumulatorError>

Checks that should be done before adding the element to the accumulator, such as the element already being present

fn check_before_remove( &self, element: &E::ScalarField, state: &dyn State<E::ScalarField> ) -> Result<(), VBAccumulatorError>

Checks that should be done before removing the element from the accumulator, such as the element already being absent

fn _compute_new_post_add( &self, element: &E::ScalarField, sk: &SecretKey<E::ScalarField> ) -> (E::ScalarField, E::G1Affine)

Compute new accumulated value after addition. Described in section 2 of the paper

fn _add( &self, element: E::ScalarField, sk: &SecretKey<E::ScalarField>, state: &mut dyn State<E::ScalarField> ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError>

Common code for adding a single member in both accumulators. Reads and writes to state. Described in section 2 of the paper

fn _compute_new_post_add_batch( &self, elements: &[E::ScalarField], sk: &SecretKey<E::ScalarField> ) -> (E::ScalarField, E::G1Affine)

Compute new accumulated value after batch addition. Described in section 3 of the paper

fn _add_batch( &self, elements: Vec<E::ScalarField>, sk: &SecretKey<E::ScalarField>, state: &mut dyn State<E::ScalarField> ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError>

Common code for adding a batch of members in both accumulators. Reads and writes to state. Described in section 3 of the paper

fn _compute_new_post_remove( &self, element: &E::ScalarField, sk: &SecretKey<E::ScalarField> ) -> (E::ScalarField, E::G1Affine)

Compute new accumulated value after removal. Described in section 2 of the paper

fn _remove( &self, element: &E::ScalarField, sk: &SecretKey<E::ScalarField>, state: &mut dyn State<E::ScalarField> ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError>

Common code for removing a single member from both accumulators. Reads and writes to state. Described in section 2 of the paper

fn _compute_new_post_remove_batch( &self, elements: &[E::ScalarField], sk: &SecretKey<E::ScalarField> ) -> (E::ScalarField, E::G1Affine)

Compute new accumulated value after batch removals. Described in section 3 of the paper

fn _remove_batch( &self, elements: &[E::ScalarField], sk: &SecretKey<E::ScalarField>, state: &mut dyn State<E::ScalarField> ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError>

Common code for removing a batch of members from both accumulators. Reads and writes to state. Described in section 3 of the paper

fn _compute_new_post_batch_updates( &self, additions: &[E::ScalarField], removals: &[E::ScalarField], sk: &SecretKey<E::ScalarField> ) -> (E::ScalarField, E::G1Affine)

Compute new accumulated value after batch additions and removals. Described in section 3 of the paper

fn _batch_updates( &self, additions: Vec<E::ScalarField>, removals: &[E::ScalarField], sk: &SecretKey<E::ScalarField>, state: &mut dyn State<E::ScalarField> ) -> Result<(E::ScalarField, E::G1Affine), VBAccumulatorError>

Common code for adding and removing batches (1 batch each) of elements in both accumulators. Reads and writes to state. Described in section 3 of the paper

fn compute_membership_witness( &self, member: &E::ScalarField, sk: &SecretKey<E::ScalarField> ) -> MembershipWitness<E::G1Affine>

Compute membership witness

fn get_membership_witness( &self, member: &E::ScalarField, sk: &SecretKey<E::ScalarField>, state: &dyn State<E::ScalarField> ) -> Result<MembershipWitness<E::G1Affine>, VBAccumulatorError>

Get membership witness for an element present in accumulator. Described in section 2 of the paper

fn compute_membership_witnesses_for_batch( &self, members: &[E::ScalarField], sk: &SecretKey<E::ScalarField> ) -> Vec<MembershipWitness<E::G1Affine>>

Compute membership witness for batch

fn get_membership_witnesses_for_batch( &self, members: &[E::ScalarField], sk: &SecretKey<E::ScalarField>, state: &dyn State<E::ScalarField> ) -> Result<Vec<MembershipWitness<E::G1Affine>>, VBAccumulatorError>

Get membership witnesses for multiple elements present in accumulator. Returns witnesses in the order of passed elements. It is more efficient than computing multiple witnesses independently as it uses windowed multiplication and batch invert. Will throw error even if one element is not present

fn verify_membership_given_accumulated( V: &E::G1Affine, member: &E::ScalarField, witness: &MembershipWitness<E::G1Affine>, pk: &PublicKey<E>, params: &SetupParams<E> ) -> bool

Check if element present in accumulator given the accumulated value. Described in section 2 of the paper

fn verify_membership( &self, member: &E::ScalarField, witness: &MembershipWitness<E::G1Affine>, pk: &PublicKey<E>, params: &SetupParams<E> ) -> bool

Check if element present in accumulator. Described in section 2 of the paper

fn randomized_value(&self, randomizer: &E::ScalarField) -> E::G1Affine

Object Safety

This trait is not object safe.

Implementors

impl<E: Pairing> Accumulator<E> for NonAdaptivePositiveAccumulator<E>

impl<E: Pairing> Accumulator<E> for UniversalAccumulator<E>

impl<E: Pairing> Accumulator<E> for PositiveAccumulator<E>