Struct TranscriptReader

pub struct TranscriptReader<Challenger> { /* private fields */ }

Readable(Verifier) transcript over some Challenger that CanRead and CanSample<F: TowerField>

You must manually call the destructor with finalize() to check anything that’s written is fully read out

Implementations

impl<Challenger: Default> TranscriptReader<Challenger>

pub fn new(vec: Vec<u8>) -> Self

pub fn finalize(self) -> Result<(), Error>

Trait Implementations

impl<Challenger_: Challenger> CanRead for TranscriptReader<Challenger_>

fn buffer(&mut self) -> impl Buf + '_

fn read<T: DeserializeBytes>(&mut self) -> Result<T, Error>

fn read_vec<T: DeserializeBytes>(&mut self, n: usize) -> Result<Vec<T>, Error>

fn read_bytes(&mut self, buf: &mut [u8]) -> Result<(), Error>

fn read_scalar<F: TowerField>(&mut self) -> Result<F, Error>

fn read_scalar_slice_into<F: TowerField>( &mut self, buf: &mut [F], ) -> Result<(), Error>

fn read_scalar_slice<F: TowerField>( &mut self, len: usize, ) -> Result<Vec<F>, Error>

fn read_packed<P: PackedField<Scalar: TowerField>>( &mut self, ) -> Result<P, Error>

fn read_packed_slice<P: PackedField<Scalar: TowerField>>( &mut self, len: usize, ) -> Result<Vec<P>, Error>

impl<F, Challenger_> CanSample<F> for TranscriptReader<Challenger_>

where F: TowerField, Challenger_: Challenger,

fn sample(&mut self) -> F

fn sample_array<const N: usize>(&mut self) -> [T; N]

fn sample_vec(&mut self, n: usize) -> Vec<T>

impl<Challenger_> CanSampleBits<usize> for TranscriptReader<Challenger_>

where Challenger_: Challenger,

fn sample_bits(&mut self, bits: usize) -> usize

impl<Challenger: Debug> Debug for TranscriptReader<Challenger>

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

Formats the value using the given formatter.

impl<Challenger> Drop for TranscriptReader<Challenger>

fn drop(&mut self)

Executes the destructor for this type.