tasm_lib/hashing/sponge_hasher/
init.rs

1use triton_vm::prelude::*;
2
3use crate::prelude::*;
4
5#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
6pub struct Init;
7
8impl BasicSnippet for Init {
9    fn inputs(&self) -> Vec<(DataType, String)> {
10        vec![]
11    }
12
13    fn outputs(&self) -> Vec<(DataType, String)> {
14        vec![]
15    }
16
17    fn entrypoint(&self) -> String {
18        "tasmlib_hashing_sponge_hasher_init".to_string()
19    }
20
21    fn code(&self, _library: &mut Library) -> Vec<LabelledInstruction> {
22        let entrypoint = self.entrypoint();
23        triton_asm!(
24            {entrypoint}:
25                sponge_init
26                return
27        )
28    }
29}
30
31#[cfg(test)]
32mod tests {
33    use arbitrary::Arbitrary;
34    use arbitrary::Unstructured;
35    use twenty_first::prelude::Sponge;
36
37    use super::*;
38    use crate::empty_stack;
39    use crate::test_prelude::*;
40
41    impl Procedure for Init {
42        fn rust_shadow(
43            &self,
44            _: &mut Vec<BFieldElement>,
45            _: &mut HashMap<BFieldElement, BFieldElement>,
46            _: &NonDeterminism,
47            _: &[BFieldElement],
48            sponge: &mut Option<Tip5>,
49        ) -> Vec<BFieldElement> {
50            *sponge = Some(Tip5::init());
51            vec![]
52        }
53
54        fn pseudorandom_initial_state(
55            &self,
56            seed: [u8; 32],
57            _: Option<BenchmarkCase>,
58        ) -> ProcedureInitialState {
59            let bytes = StdRng::from_seed(seed).random::<[u8; 400]>();
60            let mut unstructured = Unstructured::new(&bytes);
61            let sponge = Tip5::arbitrary(&mut unstructured).unwrap();
62
63            ProcedureInitialState {
64                stack: empty_stack(),
65                nondeterminism: NonDeterminism::default(),
66                public_input: vec![],
67                sponge: Some(sponge),
68            }
69        }
70    }
71
72    #[test]
73    fn sponge_init_test() {
74        ShadowedProcedure::new(Init).test();
75    }
76}
77
78#[cfg(test)]
79mod benches {
80    use super::*;
81    use crate::test_prelude::*;
82
83    #[test]
84    fn benchmark() {
85        ShadowedProcedure::new(Init).bench();
86    }
87}