Trait neptune::sponge::vanilla::SpongeTrait

source ·

pub trait SpongeTrait<'a, F: PrimeField, A: Arity<F>>where
    Self: Sized,{
    type Acc;
    type Elt;
    type Error;

Show 44 methods    // Required methods
    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, acc: &mut Self::Acc) -> Self::Elt;
    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, acc: &mut Self::Acc) -> Result<(), Self::Error>;
    fn squeeze_aux(&mut self) -> Self::Elt;
    fn absorb_aux(&mut self, elt: &Self::Elt) -> Self::Elt;
    fn enqueue(&mut self, elt: Self::Elt);
    fn dequeue(&mut self) -> Option<Self::Elt>;
    fn squeeze_elements(
        &mut self,
        count: usize,
        acc: &mut Self::Acc,
    ) -> Vec<Self::Elt>;

    // Provided methods
    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> { ... }
    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> { ... }
}