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 an error 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::InvalidData if pks exceeds the max ring size.

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::InvalidData if pks exceeds the max ring size.

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

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

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

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

where Self: 'a,