Struct neptune::sponge::circuit::SpongeCircuit

pub struct SpongeCircuit<'a, F, A, C>
where
    F: PrimeField,
    A: Arity<F>,
    C: ConstraintSystem<F>,
{ /* private fields */ }

Trait Implementations

impl<'a, F: PrimeField, A: Arity<F>, CS: 'a + ConstraintSystem<F>> InnerSpongeAPI<F, A> for SpongeCircuit<'a, F, A, CS>

type Acc = Namespace<'a, F, CS>

type Value = Elt<F>

fn initialize_capacity(&mut self, tag: u128, _acc: &mut Self::Acc)

fn read_rate_element(&mut self, offset: usize) -> Self::Value

fn add_rate_element(&mut self, offset: usize, x: &Self::Value)

fn permute(&mut self, acc: &mut Self::Acc)

fn zero() -> Elt<F>

fn rate(&self) -> usize

fn absorb_pos(&self) -> usize

fn squeeze_pos(&self) -> usize

fn set_absorb_pos(&mut self, pos: usize)

fn set_squeeze_pos(&mut self, pos: usize)

fn add(a: Elt<F>, b: &Elt<F>) -> Elt<F>

fn pattern(&self) -> &IOPattern

fn set_pattern(&mut self, pattern: IOPattern)

fn increment_io_count(&mut self) -> usize

fn initialize_state(&mut self, p_value: u128, acc: &mut Self::Acc)

impl<'a, F: PrimeField, A: Arity<F>, CS: 'a + ConstraintSystem<F>> SpongeTrait<'a, F, A> for SpongeCircuit<'a, F, A, CS>

type Acc = Namespace<'a, F, CS>

type Elt = Elt<F>

type Error = SynthesisError

fn new_with_constants( constants: &'a PoseidonConstants<F, A>, mode: Mode, ) -> Self

fn mode(&self) -> Mode

fn direction(&self) -> Direction

fn set_direction(&mut self, direction: Direction)

fn absorbed(&self) -> usize

fn set_absorbed(&mut self, absorbed: usize)

fn squeezed(&self) -> usize

fn set_squeezed(&mut self, squeezed: usize)

fn squeeze_pos(&self) -> usize

fn set_squeeze_pos(&mut self, squeeze_pos: usize)

fn absorb_pos(&self) -> usize

fn set_absorb_pos(&mut self, pos: usize)

fn element(&self, index: usize) -> Self::Elt

fn set_element(&mut self, index: usize, elt: Self::Elt)

fn make_elt(&self, val: F, ns: &mut Self::Acc) -> Self::Elt

👎Deprecated since 0.10.0

fn rate(&self) -> usize

fn capacity(&self) -> usize

fn size(&self) -> usize

fn constants(&self) -> &PoseidonConstants<F, A>

fn pad(&mut self)

fn permute_state(&mut self, ns: &mut Self::Acc) -> Result<(), Self::Error>

fn enqueue(&mut self, elt: Self::Elt)

fn dequeue(&mut self) -> Option<Self::Elt>

fn squeeze_aux(&mut self) -> Self::Elt

fn absorb_aux(&mut self, elt: &Self::Elt) -> Self::Elt

fn squeeze_elements( &mut self, count: usize, ns: &mut Self::Acc, ) -> Vec<Self::Elt>

fn simplex_constants(size: usize) -> PoseidonConstants<F, A>

fn duplex_constants() -> PoseidonConstants<F, A>

fn api_constants(strength: Strength) -> PoseidonConstants<F, A>

fn is_simplex(&self) -> bool

fn is_duplex(&self) -> bool

fn is_absorbing(&self) -> bool

fn is_squeezing(&self) -> bool

fn available(&self) -> usize

fn is_immediately_squeezable(&self) -> bool

fn total_size(&self) -> usize

fn can_squeeze_without_permuting(&self) -> bool

fn is_exhausted(&self) -> bool

fn ensure_absorbing(&mut self)

fn permute(&mut self, acc: &mut Self::Acc) -> Result<(), Self::Error>

fn ensure_squeezing(&mut self, acc: &mut Self::Acc) -> Result<(), Self::Error>

fn absorb( &mut self, elt: &Self::Elt, acc: &mut Self::Acc, ) -> Result<(), Self::Error>

Absorb one field element

fn squeeze( &mut self, acc: &mut Self::Acc, ) -> Result<Option<Self::Elt>, Self::Error>

fn absorb_elements( &mut self, elts: &[Self::Elt], acc: &mut Self::Acc, ) -> Result<(), Self::Error>