Struct ECTranscript 

pub struct ECTranscript<C: PrimeOrderCurve, T> {
    sponge: T,
    transcript: Transcript<C::Base>,
    debug: bool,
}

A transcript that operates over the base field of a prime-order curve, while also allowing for the absorption and sampling of scalar field elements (and of course, EC points).

Fields

sponge: T

The sponge that this writer is using to append/squeeze elements.

transcript: Transcript<C::Base>

A mutable transcript which keeps a record of all the append/squeeze operations.

debug: bool

Whether to print debug information.

Implementations

impl<C: PrimeOrderCurve, Tr: ECTranscriptSponge<C> + Default> ECTranscript<C, Tr>

pub fn get_transcript(self) -> Transcript<C::Base>

Destructively extract the transcript produced by this writer. This should be the last operation performed on a TranscriptWriter.

pub fn new(label: &str) -> Self

Creates an empty sponge. label is an identifier used for debugging purposes.

pub fn new_with_debug(label: &str) -> Self

Creates an empty sponge in debug mode (i.e. with debug information printed). label is an identifier used for debugging purposes.

Trait Implementations

impl<C: PrimeOrderCurve, Sp: ECTranscriptSponge<C>> Display for ECTranscript<C, Sp>

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

Formats the value using the given formatter.

impl<C: PrimeOrderCurve, Tr: ECTranscriptSponge<C> + Default> ECTranscriptTrait<C> for ECTranscript<C, Tr>

fn get_scalar_field_challenge( &mut self, label: &str, ) -> <C as PrimeOrderCurve>::Scalar

Literally takes the byte representation of the base field element and dumps it (TODO: in an unsafe manner! Make this return an error rather than just panicking) into a scalar field element’s representation.

fn get_ec_challenge(&mut self, label: &str) -> C

Generates two base field elements, and uses only the parity of the second to determine the actual y-coordinate to be used.

WARNING/TODO(ryancao): USING THIS FUNCTION num_elements TIMES WILL NOT PRODUCE THE SAME EC CHALLENGES AS CALLING Self::get_ec_challenges WITH num_elements AS A PARAMETER!!!

IN PARTICULAR, THIS FUNCTION GENERATES (x, y) ELEMENTS IN INDIVIDUAL PAIRS, WHILE THE Self::get_ec_challenges FUNCTION GENERATES (x, y) ELEMENTS BY FIRST GENERATING ALL x-coordinates AND THEN GENERATING ALL ELEMENTS DETERMINING THE PARITY OF THE CORRESPONDING y-coordinates.

fn get_ec_challenges(&mut self, label: &str, num_elements: usize) -> Vec<C>

Generates two base field elements for each element requested, by FIRST generating ALL of the x-coords and AFTERWARDS generating ALL of the base field elements whose parity determines the sign of the corresponding y-coord.

WARNING/TODO(ryancao): SEE WARNING FOR Self::get_ec_challenge!!!

fn append_ec_point(&mut self, label: &str, elem: C)

fn append_ec_points(&mut self, label: &str, elements: &[C])

fn append_scalar_field_elem(&mut self, label: &str, elem: C::Scalar)

fn append_scalar_field_elems(&mut self, label: &str, elements: &[C::Scalar])

fn get_scalar_field_challenges( &mut self, label: &str, num_elements: usize, ) -> Vec<<C as PrimeOrderCurve>::Scalar>

fn append_input_ec_points(&mut self, label: &str, elements: Vec<C>)

This function absorbs elliptic curve points as individual base field elements, and additionally absorbs the hash chain digest of the base field elements.

fn append_input_scalar_field_elems( &mut self, label: &str, elements: &[<C as PrimeOrderCurve>::Scalar], )

This function absorbs scalar field elements into the transcript sponge, and additionally absorbs the hash chain digest of these elements.

fn append_base_field_elems( &mut self, label: &str, elements: &[<C as PrimeOrderCurve>::Base], )

This function absorbs base field elements into the transcript sponge.

impl<C: PrimeOrderCurve, Sp: TranscriptSponge<C::Base>> ProverTranscript<<C as PrimeOrderCurve>::Base> for ECTranscript<C, Sp>

fn append(&mut self, label: &str, elem: C::Base)

fn append_elements(&mut self, label: &str, elements: &[C::Base])

fn get_challenge(&mut self, label: &str) -> C::Base

fn get_challenges(&mut self, label: &str, num_elements: usize) -> Vec<C::Base>

fn append_input_elements(&mut self, label: &str, elements: &[C::Base])