Poseidon hash

plonk-hashing/Cargo.toml

@@ -22,3 +22,17 @@ std = []
 
 [dependencies]
 plonk-core = { path = "../plonk-core" }
+ark-ec = { version = "0.3", features = ["std"] }
+ark-ff = { version = "0.3", features = ["std"] }
+ark-serialize = { version = "0.3", features = ["derive"] }
+ark-poly = "0.3"
+ark-poly-commit = "0.3"
+ark-crypto-primitives = { version = "^0.3.0", features = ["r1cs"], default-features = false }
+ark-std = { version = "^0.3.0", default-features = false }
+itertools = { version = "0.10.1", default-features = false }
+num-traits = "0.2.14"
+derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
+hashbrown = { version = "0.11.2", default-features = false, features = ["ahash"] }
+ark-relations = "0.3.0"
+ark-r1cs-std = "0.3.1"
+thiserror = "1.0.30"

plonk-hashing/src/lib.rs

@@ -6,7 +6,12 @@
 
 //! PLONK Hashing Library
 
-#![cfg_attr(not(any(feature = "std", test)), no_std)]
+// #![cfg_attr(not(any(feature = "std", test)), no_std)]
 #![cfg_attr(doc_cfg, feature(doc_cfg))]
 #![forbid(rustdoc::broken_intra_doc_links)]
-#![forbid(missing_docs)]
+// #![forbid(missing_docs)]
+
+#[macro_use]
+pub extern crate ark_std;
+
+pub mod poseidon;

plonk-hashing/src/poseidon/constants.rs

@@ -0,0 +1,80 @@
+use crate::poseidon::{
+    matrix::Matrix,
+    mds::{factor_to_sparse_matrixes, MdsMatrices, SparseMatrix},
+    preprocessing::compress_round_constants,
+    round_constant::generate_constants,
+    round_numbers::calc_round_numbers,
+};
+use ark_ff::PrimeField;
+use ark_std::convert::TryInto;
+use ark_std::vec::*;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PoseidonConstants<F: PrimeField> {
+    pub mds_matrices: MdsMatrices<F>,
+    pub round_constants: Vec<F>,
+    pub compressed_round_constants: Vec<F>,
+    pub pre_sparse_matrix: Matrix<F>,
+    pub sparse_matrixes: Vec<SparseMatrix<F>>,
+    pub domain_tag: F,
+    pub full_rounds: usize,
+    pub half_full_rounds: usize,
+    pub partial_rounds: usize,
+}
+
+impl<F: PrimeField> PoseidonConstants<F> {
+    // WIDTH = arity + 1. WIDTH is the *t* in Neptune's spec
+    pub fn generate<const WIDTH: usize>() -> Self {
+        let arity = WIDTH - 1;
+        let mds_matrices = MdsMatrices::new(WIDTH);
+        let (num_full_rounds, num_partial_rounds) =
+            calc_round_numbers(WIDTH, true);
+
+        debug_assert_eq!(num_full_rounds % 2, 0);
+        let num_half_full_rounds = num_full_rounds / 2;
+        let round_constants = generate_constants(
+            1, // prime field
+            1, // sbox
+            F::size_in_bits() as u16,
+            WIDTH.try_into().expect("WIDTH is too large"),
+            num_full_rounds
+                .try_into()
+                .expect("num_full_rounds is too large"),
+            num_partial_rounds
+                .try_into()
+                .expect("num_partial_rounds is too large"),
+        );
+        let domain_tag = F::from(((1 << arity) - 1) as u64);
+
+        let compressed_round_constants = compress_round_constants(
+            WIDTH,
+            num_full_rounds,
+            num_partial_rounds,
+            &round_constants,
+            &mds_matrices,
+        );
+
+        let (pre_sparse_matrix, sparse_matrixes) = factor_to_sparse_matrixes(
+            mds_matrices.m.clone(),
+            num_partial_rounds,
+        );
+
+        assert!(
+            WIDTH * (num_full_rounds + num_partial_rounds)
+                <= round_constants.len(),
+            "Not enough round constants"
+        );
+
+        PoseidonConstants {
+            mds_matrices,
+            round_constants,
+            domain_tag,
+            full_rounds: num_full_rounds,
+            half_full_rounds: num_half_full_rounds,
+            partial_rounds: num_partial_rounds,
+            compressed_round_constants,
+            pre_sparse_matrix,
+            sparse_matrixes,
+        }
+    }
+}