Struct VerifierTranscript 

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

Verifier transcript over some Challenger that reads from the internal tape and CanSample<F: Field>

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

Implementations

impl<Challenger_: Challenger> VerifierTranscript<Challenger_>

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

pub fn with_opts( challenger: Challenger_, vec: Vec<u8>, options: Options, ) -> Self

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

pub fn observe<'a, 'b>(&'a mut self) -> TranscriptWriter<'b, impl BufMut + 'b>

where 'a: 'b,

Returns a writable buffer that only observes the data written, without reading it from the proof tape.

This method should be used to observe the input statement.

pub fn decommitment(&mut self) -> TranscriptReader<'_, impl Buf + '_>

Returns a readable buffer that only reads the data from the proof tape, without observing it.

This method should only be used to read advice that was previously written to the transcript as an observed message.

pub fn message<'a, 'b>(&'a mut self) -> TranscriptReader<'b, impl Buf>

where 'a: 'b,

Returns a readable buffer that observes the data read.

This method should be used by default to read verifier messages in an interactive protocol.

pub fn verify_grind(&mut self, bits: usize) -> Result<u64, Error>

Checks the proof of work that ProverTranscript::grind wrote, returning its nonce.

Reads the nonce as a message, so the challenger observes the same bytes the prover fed it. Then samples bits and requires every one of them to be zero. Both transcripts consume the same challenger state either way. So a caller may keep going after an error without the two sides drifting apart.

Errors

Returns Error::InsufficientWork when the sampled bits are not all zero. Returns a deserialization error when the tape holds no nonce.

Preconditions

• bits must be at most 32, which is the width the sampler masks to.

Trait Implementations

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

where F: Field, 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<u32> for VerifierTranscript<Challenger_>

where Challenger_: Challenger,

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

impl<Challenger: Clone> Clone for VerifierTranscript<Challenger>

fn clone(&self) -> VerifierTranscript<Challenger>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Challenger: Debug> Debug for VerifierTranscript<Challenger>

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

Formats the value using the given formatter.

impl<Challenger> Drop for VerifierTranscript<Challenger>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.