Struct SizeTrackingChannel 

pub struct SizeTrackingChannel<'a, F, MerkleScheme_> { /* private fields */ }

A Merkle channel that counts the bytes a proof would occupy, without checking any of them.

Every receive returns zeros and adds what the real bytes would weigh. Sampling returns zeros too, so nothing here needs a prover.

Counting at this layer measures a protocol by running it, rather than by a formula kept in step with it by hand. Anything speaking this interface can be measured, oracle reduction or not.

Zero survives every fold and equality check a verifier performs. So the verifier takes the path it would on a real proof, reaching the same receives in order.

Implementations

impl<'a, F, MerkleScheme_> SizeTrackingChannel<'a, F, MerkleScheme_>

pub const fn new(scheme: &'a MerkleScheme_) -> Self

Creates a channel that sizes openings for the given scheme.

pub const fn proof_size(&self) -> usize

The bytes counted so far.

Trait Implementations

impl<F, MerkleScheme_> GrindingVerifierChannel for SizeTrackingChannel<'_, F, MerkleScheme_>

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

Checks the proof of work of bits difficulty standing at this point in the transcript.

impl<F, MerkleScheme_> IPVerifierChannel<F> for SizeTrackingChannel<'_, F, MerkleScheme_>

where F: BinaryField + FixedSizeSerializeBytes, MerkleScheme_: MerkleTreeScheme<F>,

type Elem = F

The element type returned by receive and sample methods.

fn recv_one(&mut self) -> Result<F, Error>

Receives a single field element from the prover.

fn recv_many(&mut self, n: usize) -> Result<Vec<F>, Error>

Receives n field elements from the prover.

fn recv_array<const N: usize>(&mut self) -> Result<[F; N], Error>

Receives a fixed-size array of field elements from the prover.

fn sample(&mut self) -> F

Samples a random challenge.

fn observe_one(&mut self, _val: F) -> F

Observes a single field element, feeding it into the Fiat-Shamir state.

fn observe_many(&mut self, vals: &[F]) -> Vec<F>

Observes multiple field elements, feeding them into the Fiat-Shamir state.

fn assert_zero(&mut self, _val: F) -> Result<(), Error>

Asserts that a value is zero.

fn recv_public_claim(&mut self) -> Result<Self::Elem, Error>

Receives a value the verifier could compute for itself, taken as advice.

fn sample_many(&mut self, n: usize) -> Vec<Self::Elem>

Samples n random challenges.

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

Samples a fixed-size array of random challenges.

impl<F, MerkleScheme_> MerkleIPVerifierChannel<F> for SizeTrackingChannel<'_, F, MerkleScheme_>

where F: BinaryField + FixedSizeSerializeBytes, MerkleScheme_: MerkleTreeScheme<F>,

type Commitment = CommittedShape

A Merkle commitment.

fn recv_merkle_commitment( &mut self, leaf_size: usize, depth: usize, ) -> Result<Self::Commitment, Error>

Receives a Merkle commitment for a tree with the given depth and leaf size.

fn recv_openings( &mut self, commitment: &Self::Commitment, indices: &[Word], ) -> Result<Vec<F>, Error>

Receives a multi-opening of leaves, bound by a Merkle commitment.

fn recv_committed_vector( &mut self, commitment: &Self::Commitment, ) -> Result<Vec<F>, Error>

Receives the full committed vector, bound by a Merkle commitment.

impl<F, MerkleScheme_> WordIPVerifierChannel<F> for SizeTrackingChannel<'_, F, MerkleScheme_>

where F: BinaryField + FixedSizeSerializeBytes, MerkleScheme_: MerkleTreeScheme<F>,

type Word = Word

The word type this channel carries.

fn observe_words(&mut self, words: &[Word]) -> Vec<Word>

Feeds words into the Fiat-Shamir state, each as eight little-endian bytes, and returns them as this channel’s word type.

fn subset_sum(&mut self, elems: &[F], word: &Word) -> F

Returns the sum of the elems selected by the low bits of word, low bit first.

fn select(&mut self, elems: &[F], word: &Word) -> F

Returns the element of elems at the index in the low bits of word.

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

Samples a uniform word of the given bit width.

fn pack_words(&mut self, words: &[Word]) -> Vec<F>

Packs words into field elements, as many words to an element as one holds.