Struct Omega

pub struct Omega<G: AffineRepr>(pub Vec<G>);

Published by the accumulator manager to allow witness updates without secret info. This “represents” a polynomial which will be evaluated at the element whose witness needs to be updated. Its a binding but non-hiding commitment to the polynomial. Defined in section 4.1 of the paper

Tuple Fields

0: Vec<G>

Implementations

impl<G> Omega<G>

where G: AffineRepr,

pub fn new( additions: &[G::ScalarField], removals: &[G::ScalarField], old_accumulator: &G, sk: &SecretKey<G::ScalarField>, ) -> Self

Create new Omega after additions are added and removals are removed from old_accumulator. Note that old_accumulator is the accumulated value before the updates were made. Returns c_0 * V, c_1 * V, ..., c_n * V where V is the accumulator before the update and c_i are the coefficients of the polynomial v_AD

pub fn new_for_kb_positive_accumulator<D: Default + DynDigest + Clone>( removals: &[G::ScalarField], old_accumulator: &G, sk: &SecretKey<G::ScalarField>, ) -> Self

Create Omega for KB positive accumulator after removals are removed from old_accumulator. Returns c_0 * -V, c_1 * -V, ..., c_n * -V where V is the accumulator before the update and c_i are the coefficients of the polynomial v_D. As this accumulator does not change on additions, only polynomial v_D is generated.

pub fn new_for_kb_universal_accumulator( additions: &[G::ScalarField], removals: &[G::ScalarField], old_mem_accumulator: &G, old_non_mem_accumulator: &G, sk: &SecretKey<G::ScalarField>, ) -> (Self, Self)

Create 2 Omegas for KB universal accumulator. As this accumulator comprises of 2 positive accumulators, this returns 2 Omegas, one for each of those accumulators

pub fn evaluate(&self, y: &G::ScalarField, scalar: &G::ScalarField) -> G::Group

Inner product of powers of y, i.e. the element for which witness needs to be updated and omega. Equivalent to evaluating the polynomial at y and multiplying the result by scalar Used by the (non)member to update its witness without the knowledge of secret key.

pub fn scaled_powers_of_y( y: &G::ScalarField, scalar: &G::ScalarField, n: usize, ) -> Vec<G::ScalarField>

Return [scalar1, scalary, scalary^2, scalary^3, …, scalar*y^{n-1}]

pub fn scaled(&self, scalar: &G::ScalarField) -> Vec<G::Group>

Scale the omega vector by the given scalar

pub fn len(&self) -> usize

pub fn coefficient(&self, i: usize) -> &G

Coefficient (c_i) at the ith position

pub fn from(coeffs: Vec<G>) -> Self

Trait Implementations

impl<G: AffineRepr> CanonicalDeserialize for Omega<G>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<G: AffineRepr> CanonicalSerialize for Omega<G>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<G: Clone + AffineRepr> Clone for Omega<G>

fn clone(&self) -> Omega<G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: Debug + AffineRepr> Debug for Omega<G>

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

Formats the value using the given formatter.

impl<'de, G: AffineRepr> Deserialize<'de> for Omega<G>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G: PartialEq + AffineRepr> PartialEq for Omega<G>

fn eq(&self, other: &Omega<G>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<G: AffineRepr> Serialize for Omega<G>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<G: AffineRepr> Valid for Omega<G>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl<G: Eq + AffineRepr> Eq for Omega<G>

impl<G: AffineRepr> StructuralPartialEq for Omega<G>