Struct RingSetup 

pub struct RingSetup<S: RingSuite> {
    pub pcs_params: PcsParams<S>,
    pub ring_ctx: RingContext<S>,
}

Ring proof setup.

Contains the cryptographic parameters needed for ring proof key construction, proving and verification:

• pcs_params: Polynomial Commitment Scheme parameters (KZG setup)
• ring_ctx: Ring context containing the PIOP parameters

Fields

pcs_params: PcsParams<S>

PCS parameters.

ring_ctx: RingContext<S>

Ring context (PIOP parameters).

Implementations

impl<S: RingSuite> RingSetup<S>

pub fn from_seed(ring_size: usize, seed: [u8; 32]) -> Self

Construct deterministic ring proof params for the given ring size.

Creates parameters using a transcript-based RNG seeded with seed.

pub fn from_rand(ring_size: usize, rng: &mut impl RngCore) -> Self

Construct random ring proof params for the given ring size.

Generates a new KZG setup with sufficient degree to support the specified ring size.

pub fn from_pcs_params( ring_size: usize, pcs_params: PcsParams<S>, ) -> Result<Self, Error>

Construct ring proof params from existing KZG setup.

Truncates the setup if larger than needed, or returns Error::RingCapacityExceeded if it is insufficient for the specified ring size.

pub fn prover_key( &self, pks: &[AffinePoint<S>], ) -> Result<RingProverKey<S>, Error>

Create a prover key for the given ring of public keys.

Returns Error::RingCapacityExceeded if pks exceeds the max ring size, Error::InvalidData if a key cannot be mapped to Twisted Edwards form.

pub fn verifier_key( &self, pks: &[AffinePoint<S>], ) -> Result<RingVerifierKey<S>, Error>

Create a verifier key for the given ring of public keys.

Returns Error::RingCapacityExceeded if pks exceeds the max ring size, Error::InvalidData if a key cannot be mapped to Twisted Edwards form.

pub fn verifier_key_from_commitment( &self, commitment: RingCommitment<S>, ) -> RingVerifierKey<S>

Create a verifier key from a precomputed ring commitment.

The commitment can be obtained from an existing verifier key via RingVerifierKey::commitment.

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

Extract the PCS parameters required by the verifier.

Small (a few points) and independent of ring size. Sufficient, together with a ring commitment, to reconstruct a verifier key via verifier_key_from_commitment without access to the full setup.

pub fn verifier_key_builder( &self, ) -> (VerifierKeyBuilder<S>, RingBuilderPcsParams<S>)

Create a builder for incremental construction of the verifier key.

pub fn ring_context(&self) -> &RingContext<S>

Get a reference to the lightweight RingContext.

pub const fn padding_point() -> AffinePoint<S>

Get the padding point.

This is a point of unknown dlog that can be used in place of any key during ring construction.

Methods from Deref<Target = RingContext<S>>

pub fn max_ring_size(&self) -> usize

The max ring size this context is able to handle.

pub fn ring_prover( &self, prover_key: RingProverKey<S>, key_index: usize, ) -> RingProver<S>

Create a prover instance for a specific position in the ring.

pub fn ring_verifier(&self, verifier_key: RingVerifierKey<S>) -> RingVerifier<S>

Create a verifier instance from a verifier key.

Trait Implementations

impl<S: RingSuite> CanonicalDeserialize for RingSetup<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 RingSetup<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 RingSetup<S>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: RingSuite> Deref for RingSetup<S>

type Target = RingContext<S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

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.

const TRIVIAL_CHECK: bool = false

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 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.