Struct nimue::Arthur

pub struct Arthur<'a, H = DefaultHash, U = u8>
where
    H: DuplexHash<U>,
    U: Unit,
{ /* private fields */ }

Arthur contains the verifier state. Internally, it is a wrapper around a SAFE sponge. Given as input an IOPattern and a protocol transcript, it allows to de-serialize elements from the transcript and make them available to the zero-knowledge verifier.

Implementations

impl<'a, U: Unit, H: DuplexHash<U>> Arthur<'a, H, U>

pub fn new(io_pattern: &IOPattern<H, U>, transcript: &'a [u8]) -> Self

Creates a new Arthur instance with the given sponge and IO Pattern.

The resulting object will act as the verifier in a zero-knowledge protocol.

let io = IOPattern::<DefaultHash>::new("📝").absorb(1, "inhale 🫁").squeeze(32, "exhale 🎏");
// A silly transcript for the example.
let transcript = &[0x42];
let mut arthur = io.to_arthur(transcript);
assert_eq!(arthur.next_bytes().unwrap(), [0x42]);
let challenge = arthur.challenge_bytes::<32>();
assert!(challenge.is_ok());
assert_ne!(challenge.unwrap(), [0; 32]);

pub fn fill_next_units(&mut self, input: &mut [U]) -> Result<(), IOPatternError>

Read input.len() elements from the transcript.

pub fn ratchet(&mut self) -> Result<(), IOPatternError>

Signals the end of the statement.

pub fn preprocess(self) -> Result<&'static [U], IOPatternError>

Signals the end of the statement and returns the (compressed) sponge state.

Trait Implementations

impl<'a, H, C, const N: usize> ByteChallenges for Arthur<'a, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>,

fn fill_challenge_bytes( &mut self, output: &mut [u8] ) -> Result<(), IOPatternError>

fn challenge_bytes<const N: usize>(&mut self) -> Result<[u8; N], IOPatternError>

impl<'a, H, C, const N: usize> BytePublic for Arthur<'a, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>,

fn public_bytes(&mut self, input: &[u8]) -> Result<(), IOPatternError>

impl<'a, H: DuplexHash<u8>> ByteReader for Arthur<'a, H, u8>

fn fill_next_bytes(&mut self, input: &mut [u8]) -> Result<(), IOPatternError>

Read the next input.len() bytes from the transcript and return them.

fn next_bytes<const N: usize>(&mut self) -> Result<[u8; N], IOPatternError>

impl<'a, H: DuplexHash<U>, U: Unit> Debug for Arthur<'a, H, U>

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

Formats the value using the given formatter.

impl<H, C, const N: usize> FieldPublic<Fp<C, N>> for Arthur<'_, H, Fp<C, N>>

where H: DuplexHash<Fp<C, N>>, C: FpConfig<N>,

type Repr = ()

fn public_scalars(&mut self, input: &[Fp<C, N>]) -> ProofResult<Self::Repr>

impl<'a, F, H, const N: usize> FieldReader<F> for Arthur<'a, H>

where H: DuplexHash, F: PrimeField<Repr = [u8; N]>,

fn fill_next_scalars(&mut self, output: &mut [F]) -> ProofResult<()>

fn next_scalars<const N: usize>(&mut self) -> ProofResult<[F; N]>

impl<'a, F, H> FieldReader<F> for Arthur<'a, H>

where F: Field, H: DuplexHash,

fn fill_next_scalars(&mut self, output: &mut [F]) -> ProofResult<()>

fn next_scalars<const N: usize>(&mut self) -> ProofResult<[F; N]>

impl<'a, H, C, const N: usize> FieldReader<Fp<C, N>> for Arthur<'a, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>,

fn fill_next_scalars(&mut self, output: &mut [Fp<C, N>]) -> ProofResult<()>

fn next_scalars<const N: usize>(&mut self) -> ProofResult<[F; N]>

impl<H, C, const N: usize, G> GroupPublic<G> for Arthur<'_, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>, G: CurveGroup<BaseField = Fp<C, N>>,

type Repr = ()

In order to be added to the sponge, elements may be serialize into another format. This associated type represents the format used, so that other implementation can potentially re-use the serialized element.

fn public_points(&mut self, input: &[G]) -> ProofResult<Self::Repr>

Incorporate group elements into the proof without adding them to the final protocol transcript.

impl<'a, G, H> GroupReader<G> for Arthur<'a, H>

where G: CurveGroup, H: DuplexHash,

fn fill_next_points(&mut self, output: &mut [G]) -> ProofResult<()>

Deserialize group elements from the protocol transcript into output.

fn next_points<const N: usize>(&mut self) -> ProofResult<[G; N]>

Deserialize group elements from the protocol transcript and return them.

impl<'a, P, H, C, const N: usize> GroupReader<Projective<P>> for Arthur<'a, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>, P: TECurveConfig<BaseField = Fp<C, N>>,

fn fill_next_points( &mut self, output: &mut [EdwardsCurve<P>] ) -> ProofResult<()>

Deserialize group elements from the protocol transcript into output.

fn next_points<const N: usize>(&mut self) -> ProofResult<[G; N]>

Deserialize group elements from the protocol transcript and return them.

impl<'a, P, H, C, const N: usize> GroupReader<Projective<P>> for Arthur<'a, H, Fp<C, N>>

where C: FpConfig<N>, H: DuplexHash<Fp<C, N>>, P: SWCurveConfig<BaseField = Fp<C, N>>,

fn fill_next_points(&mut self, output: &mut [SWCurve<P>]) -> ProofResult<()>

Deserialize group elements from the protocol transcript into output.

fn next_points<const N: usize>(&mut self) -> ProofResult<[G; N]>

Deserialize group elements from the protocol transcript and return them.

impl<'a, H: DuplexHash<U>, U: Unit> UnitTranscript<U> for Arthur<'a, H, U>

fn public_units(&mut self, input: &[U]) -> Result<(), IOPatternError>

Add native elements to the sponge without writing them to the protocol transcript.

fn fill_challenge_units( &mut self, input: &mut [U] ) -> Result<(), IOPatternError>

Get a challenge of count elements.