Struct VerifierKeyBuilder 

pub struct VerifierKeyBuilder<S: RingSuite> { /* private fields */ }

Builder for incremental construction of ring verifier keys.

Allows constructing a verifier key by adding public keys in batches, which is useful for large rings or memory-constrained environments.

Implementations

impl<S: RingSuite> VerifierKeyBuilder<S>

pub fn new(ring_setup: &RingSetup<S>, lookup: impl SrsLookup<S>) -> Self

Create a new empty ring verifier key builder.

pub fn free_slots(&self) -> usize

Get the number of remaining slots available in the ring.

pub fn pcs_verifier_params(&self) -> PcsVerifierParams<S>

Get the PCS parameters required by the verifier.

Same value as RingSetup::pcs_verifier_params for the setup this builder was created from.

pub fn append( &mut self, pks: &[AffinePoint<S>], lookup: impl SrsLookup<S>, ) -> Result<(), Error>

Add public keys to the ring being built.

On failure nothing is appended. Returns Error::RingCapacityExceeded if the keys do not fit in the ring (Self::free_slots gives the remaining capacity), Error::SrsLookupFailed if the SRS lookup fails, Error::InvalidData if a key cannot be mapped to Twisted Edwards form.

pub fn finalize(self) -> RingVerifierKey<S>

Complete the building process and create the verifier key.

Trait Implementations

impl<S: RingSuite> CanonicalDeserialize for VerifierKeyBuilder<S>

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,

Reads Self from reader using the compressed form if applicable. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the compressed form if applicable, without validating the deserialized value.

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

where R: Read,

Reads Self from reader using the uncompressed form. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the uncompressed form, without validating the deserialized value.

impl<S: RingSuite> CanonicalSerialize for VerifierKeyBuilder<S>

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

Returns the size in bytes of the serialized version of self with the given compression mode.

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

where W: Write,

Serializes self into writer using the compressed form if applicable.

fn compressed_size(&self) -> usize

Returns the size in bytes of the compressed serialized version of self.

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

where W: Write,

Serializes self into writer using the uncompressed form.

fn uncompressed_size(&self) -> usize

Returns the size in bytes of the uncompressed serialized version of self.

impl<S: Clone + RingSuite> Clone for VerifierKeyBuilder<S>

fn clone(&self) -> VerifierKeyBuilder<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: RingSuite> Valid for VerifierKeyBuilder<S>

const TRIVIAL_CHECK: bool

Whether the check method is trivial (i.e. always returns Ok(())). If this is true, the batch_check method will skip all checks and return Ok(()). This should be set to true for types where check is trivial, e.g. integers, field elements, etc. This is false by default. This is primarily an optimization to skip unnecessary checks in batch_check.

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

Checks whether self is valid. If self is valid, returns Ok(()). Otherwise, returns an error describing the failure. This method is called by deserialize_with_mode if validate is Validate::Yes.

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

where Self: 'a,

Checks whether all items in batch are valid. If all items are valid, returns Ok(()). Otherwise, returns an error describing the first failure.