diff --git a/filecoin-hashers/src/generic/blake2s.rs b/filecoin-hashers/src/generic/blake2s.rs
new file mode 100644
index 000000000..b686ce895
--- /dev/null
+++ b/filecoin-hashers/src/generic/blake2s.rs
@@ -0,0 +1,577 @@
+use std::cmp::Ordering;
+use std::fmt::{self, Debug, Formatter};
+use std::marker::PhantomData;
+
+use bellperson::{
+    gadgets::{
+        blake2s::blake2s as blake2s_circuit, boolean::Boolean, multipack, num::AllocatedNum,
+    },
+    ConstraintSystem, SynthesisError,
+};
+use blake2s_simd::{Hash as Blake2sHash, Params as Blake2sBuilder, State};
+use blstrs::Scalar as Fr;
+use ff::PrimeField;
+use merkletree::{
+    hash::{Algorithm, Hashable},
+    merkle::Element,
+};
+use pasta_curves::{Fp, Fq};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+use crate::{Domain, Hasher, HashFunction};
+
+#[derive(Copy, Clone, PartialEq, Eq, Default)]
+pub struct Blake2sDomain<F: PrimeField<Repr = [u8; 32]>> {
+    pub state: [u8; 32],
+    _f: PhantomData<F>,
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Debug for Blake2sDomain<F> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Blake2sDomain({})", hex::encode(&self.state))
+    }
+}
+
+// Don't blanket `impl<F> From<F> for Blake2sDomain<F> where F: PrimeField` because `PrimeField` is
+// an externally defined trait which can have external implementors (which can result in conflicting
+// implementations), e.g. if we blanket impl `impl From<[u8; 32]> for Blake2sDomain<F> where F:
+// PrimeField` because `[u8; 32]` can implement `PrimeField`.
+impl From<Fr> for Blake2sDomain<Fr> {
+    fn from(f: Fr) -> Self {
+        Blake2sDomain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+impl From<Fp> for Blake2sDomain<Fp> {
+    fn from(f: Fp) -> Self {
+        Blake2sDomain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+impl From<Fq> for Blake2sDomain<Fq> {
+    fn from(f: Fq) -> Self {
+        Blake2sDomain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+
+impl Into<Fr> for Blake2sDomain<Fr> {
+    fn into(self) -> Fr {
+        Fr::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+impl Into<Fp> for Blake2sDomain<Fp> {
+    fn into(self) -> Fp {
+        Fp::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+impl Into<Fq> for Blake2sDomain<Fq> {
+    fn into(self) -> Fq {
+        Fq::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+
+impl From<Fr> for Blake2sDomain<Fp> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::Blake2sDomain (Pallas)")
+    }
+}
+impl From<Fr> for Blake2sDomain<Fq> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::Blake2sDomain (Vesta)")
+    }
+}
+
+impl Into<Fr> for Blake2sDomain<Fp> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::Blake2sDomain (Pallas) into BLS12-381 scalar");
+    }
+}
+impl Into<Fr> for Blake2sDomain<Fq> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::Blake2sDomain (Vesta) into BLS12-381 scalar");
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> From<[u8; 32]> for Blake2sDomain<F> {
+    fn from(bytes: [u8; 32]) -> Self {
+        Blake2sDomain {
+            state: bytes,
+            _f: PhantomData,
+        }
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> From<Blake2sHash> for Blake2sDomain<F> {
+    fn from(digest: Blake2sHash) -> Self {
+        let mut domain = Blake2sDomain {
+            state: *digest.as_array(),
+            _f: PhantomData,
+        };
+        domain.trim_to_fr32();
+        domain
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<[u8]> for Blake2sDomain<F> {
+    fn as_ref(&self) -> &[u8] {
+        &self.state
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<Self> for Blake2sDomain<F> {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+// Impl `PartialOrd` and `Ord` by hand because we can't derive them due to `F: PrimeField` not
+// implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> PartialOrd for Blake2sDomain<F> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.state.partial_cmp(&other.state)
+    }
+}
+impl<F: PrimeField<Repr = [u8; 32]>> Ord for Blake2sDomain<F> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.state.cmp(&other.state)
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Element for Blake2sDomain<F> {
+    fn byte_len() -> usize {
+        32
+    }
+
+    fn from_slice(bytes: &[u8]) -> Self {
+        assert_eq!(bytes.len(), Self::byte_len(), "invalid number of bytes");
+        let mut state = [0u8; 32];
+        state.copy_from_slice(bytes);
+        state.into()
+    }
+
+    fn copy_to_slice(&self, bytes: &mut [u8]) {
+        bytes.copy_from_slice(&self.state);
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> std::hash::Hash for Blake2sDomain<F> {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        std::hash::Hash::hash(&self.state, hasher);
+    }
+}
+
+// Implement `Serialize` and `Deserialize` by hand because we can't derive them due to `F:
+// PrimeField` not implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> Serialize for Blake2sDomain<F> {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        self.state.serialize(s)
+    }
+}
+impl<'de, F: PrimeField<Repr = [u8; 32]>> Deserialize<'de> for Blake2sDomain<F> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        <[u8; 32]>::deserialize(d).map(Into::into)
+    }
+}
+
+impl Domain for Blake2sDomain<Fr> {
+    type Field = Fr;
+}
+
+impl Domain for Blake2sDomain<Fp> {
+    type Field = Fp;
+}
+
+impl Domain for Blake2sDomain<Fq> {
+    type Field = Fq;
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Blake2sDomain<F> {
+    pub fn trim_to_fr32(&mut self) {
+        // Strip the last (most-signifigant) two bits to ensure that we state within the ~256-bit
+        // field `F`; note the fields `Fr`, `Fp`, and `Fq` are each 255-bit fields and fully utilize
+        // 254 bits, i.e. `254 < log2(field_modulus) < 255`.
+        self.state[31] &= 0b0011_1111;
+    }
+}
+
+#[derive(Clone)]
+pub struct Blake2sFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    hasher: State,
+    _f: PhantomData<F>,
+}
+
+impl<F> Default for Blake2sFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    fn default() -> Self {
+        Blake2sFunction {
+            hasher: Blake2sBuilder::new().hash_length(32).to_state(),
+            _f: PhantomData,
+        }
+    }
+}
+
+// TODO (jake): do we need `PartialEq` on a hash function? Checking for equality using `Debug` isn't
+// (afaik) doing what we think it is...
+/*
+impl<F: PrimeField<Repr = [u8; 32]>> PartialEq for Blake2sFunction<F> {
+    fn eq(&self, other: &Self) -> bool {
+        format!("{:?}", self.inner) == format!("{:?}", other.inner)
+    }
+}
+
+impl Eq for Blake2sFunction {}
+*/
+
+impl<F> Debug for Blake2sFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Blake2sFunction({:?})", self.hasher)
+    }
+}
+
+impl<F> std::hash::Hasher for Blake2sFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    fn write(&mut self, msg: &[u8]) {
+        self.hasher.update(msg);
+    }
+
+    fn finish(&self) -> u64 {
+        unreachable!("unused by Function -- should never be called")
+    }
+}
+
+impl<F> Hashable<Blake2sFunction<F>> for Blake2sDomain<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    fn hash(&self, hasher: &mut Blake2sFunction<F>) {
+        <Blake2sFunction<F> as std::hash::Hasher>::write(hasher, self.as_ref());
+    }
+}
+
+impl<F> Algorithm<Blake2sDomain<F>> for Blake2sFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    fn hash(&mut self) -> Blake2sDomain<F> {
+        self.hasher.clone().finalize().into()
+    }
+
+    fn reset(&mut self) {
+        self.hasher = Blake2sBuilder::new().hash_length(32).to_state();
+    }
+
+    fn leaf(&mut self, leaf: Blake2sDomain<F>) -> Blake2sDomain<F> {
+        leaf
+    }
+
+    fn node(
+        &mut self,
+        left: Blake2sDomain<F>,
+        right: Blake2sDomain<F>,
+        _height: usize,
+    ) -> Blake2sDomain<F> {
+        left.hash(self);
+        right.hash(self);
+        self.hash()
+    }
+
+    fn multi_node(&mut self, parts: &[Blake2sDomain<F>], _height: usize) -> Blake2sDomain<F> {
+        for part in parts {
+            part.hash(self);
+        }
+        self.hash()
+    }
+}
+
+// Specialized implementation of `HashFunction` over the BLS12-381 scalar field `Fr` because that
+// field is the only one which is compatible with `HashFunction`'s circuit inferfaces.
+impl HashFunction<Blake2sDomain<Fr>> for Blake2sFunction<Fr> {
+    fn hash(data: &[u8]) -> Blake2sDomain<Fr> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(data)
+            .finalize()
+            .into()
+    }
+
+    fn hash2(a: &Blake2sDomain<Fr>, b: &Blake2sDomain<Fr>) -> Blake2sDomain<Fr> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(a.as_ref())
+            .update(b.as_ref())
+            .finalize()
+            .into()
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut cs: CS,
+        leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let mut bits = Vec::with_capacity(leaves.len() * Fr::CAPACITY as usize);
+        for (i, leaf) in leaves.iter().enumerate() {
+            bits.extend_from_slice(
+                &leaf.to_bits_le(cs.namespace(|| format!("{}_num_into_bits", i)))?,
+            );
+            while bits.len() % 8 != 0 {
+                bits.push(Boolean::Constant(false));
+            }
+        }
+        Self::hash_circuit(cs, &bits)
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        cs: CS,
+        left: &[Boolean],
+        right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let mut preimage: Vec<Boolean> = vec![];
+
+        preimage.extend_from_slice(left);
+        while preimage.len() % 8 != 0 {
+            preimage.push(Boolean::Constant(false));
+        }
+
+        preimage.extend_from_slice(right);
+        while preimage.len() % 8 != 0 {
+            preimage.push(Boolean::Constant(false));
+        }
+
+        Self::hash_circuit(cs, &preimage[..])
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut cs: CS,
+        bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let personalization = vec![0u8; 8];
+        let alloc_bits = blake2s_circuit(cs.namespace(|| "hash"), bits, &personalization)?;
+
+        multipack::pack_bits(cs.namespace(|| "pack"), &alloc_bits)
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        mut cs: CS,
+        a_num: &AllocatedNum<Fr>,
+        b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        // Allocate as booleans
+        let a = a_num.to_bits_le(cs.namespace(|| "a_bits"))?;
+        let b = b_num.to_bits_le(cs.namespace(|| "b_bits"))?;
+
+        let mut preimage: Vec<Boolean> = vec![];
+
+        preimage.extend_from_slice(&a);
+        while preimage.len() % 8 != 0 {
+            preimage.push(Boolean::Constant(false));
+        }
+
+        preimage.extend_from_slice(&b);
+        while preimage.len() % 8 != 0 {
+            preimage.push(Boolean::Constant(false));
+        }
+
+        Self::hash_circuit(cs, &preimage[..])
+    }
+}
+
+// Specialized implementation of `HashFunction` over the Pasta scalar fields `Fp` and `Fq` because
+// those fields are incompatible with `HashFunction`'s circuit inferfaces.
+impl HashFunction<Blake2sDomain<Fp>> for Blake2sFunction<Fp> {
+    fn hash(data: &[u8]) -> Blake2sDomain<Fp> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(data)
+            .finalize()
+            .into()
+    }
+
+    fn hash2(a: &Blake2sDomain<Fp>, b: &Blake2sDomain<Fp>) -> Blake2sDomain<Fp> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(a.as_ref())
+            .update(b.as_ref())
+            .finalize()
+            .into()
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _a_num: &AllocatedNum<Fr>,
+        _b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+}
+impl HashFunction<Blake2sDomain<Fq>> for Blake2sFunction<Fq> {
+    fn hash(data: &[u8]) -> Blake2sDomain<Fq> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(data)
+            .finalize()
+            .into()
+    }
+
+    fn hash2(a: &Blake2sDomain<Fq>, b: &Blake2sDomain<Fq>) -> Blake2sDomain<Fq> {
+        Blake2sBuilder::new()
+            .hash_length(32)
+            .to_state()
+            .update(a.as_ref())
+            .update(b.as_ref())
+            .finalize()
+            .into()
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _a_num: &AllocatedNum<Fr>,
+        _b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Blake2sFunction cannot be used within Groth16 circuits")
+    }
+}
+
+#[derive(Default, Copy, Clone, PartialEq, Eq, Debug)]
+pub struct Blake2sHasher<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Blake2sDomain<F>: From<F> + Into<F>,
+{
+    _f: PhantomData<F>,
+}
+
+impl Hasher for Blake2sHasher<Fr> {
+    type Domain = Blake2sDomain<Fr>;
+    type Function = Blake2sFunction<Fr>;
+
+    fn name() -> String {
+        "Blake2sHasher".into()
+    }
+}
+
+impl Hasher for Blake2sHasher<Fp> {
+    type Domain = Blake2sDomain<Fp>;
+    type Function = Blake2sFunction<Fp>;
+
+    fn name() -> String {
+        "Blake2sHasher_pallas".into()
+    }
+}
+
+impl Hasher for Blake2sHasher<Fq> {
+    type Domain = Blake2sDomain<Fq>;
+    type Function = Blake2sFunction<Fq>;
+
+    fn name() -> String {
+        "Blake2sHasher_vesta".into()
+    }
+}
diff --git a/filecoin-hashers/src/generic/mod.rs b/filecoin-hashers/src/generic/mod.rs
new file mode 100644
index 000000000..ef8d72172
--- /dev/null
+++ b/filecoin-hashers/src/generic/mod.rs
@@ -0,0 +1,91 @@
+#[cfg(feature = "blake2s")]
+pub mod blake2s;
+#[cfg(feature = "poseidon")]
+pub mod poseidon;
+#[cfg(feature = "sha256")]
+pub mod sha256;
+
+#[cfg(feature = "blake2s")]
+pub use blake2s::{Blake2sDomain, Blake2sFunction, Blake2sHasher};
+#[cfg(feature = "poseidon")]
+pub use poseidon::{PoseidonDomain, PoseidonFunction, PoseidonHasher};
+#[cfg(feature = "sha256")]
+pub use sha256::{Sha256Domain, Sha256Function, Sha256Hasher};
+
+// Rexport each hasher over the field `Fr` which is compatible with Groth16.
+pub mod groth {
+    #[cfg(any(feature = "blake2s", feature = "poseidon", feature = "sha256"))]
+    use blstrs::Scalar as Fr;
+
+    // BLS12-381
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sDomain = super::Blake2sDomain<Fr>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sFunction = super::Blake2sFunction<Fr>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sHasher = super::Blake2sHasher<Fr>;
+
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonDomain = super::PoseidonDomain<Fr>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonFunction = super::PoseidonFunction<Fr>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonHasher = super::PoseidonHasher<Fr>;
+
+    #[cfg(feature = "sha256")]
+    pub type Sha256Domain = super::Sha256Domain<Fr>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256Function = super::Sha256Function<Fr>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256Hasher = super::Sha256Hasher<Fr>;
+}
+
+// Rexport each hasher over the fields `Fp` and `Fq`  which are compatible with Halo2.
+pub mod halo {
+    #[cfg(any(feature = "blake2s", feature = "poseidon", feature = "sha256"))]
+    use pasta_curves::{Fp, Fq};
+
+    // Pallas
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sDomainPallas = super::Blake2sDomain<Fp>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sFunctionPallas = super::Blake2sFunction<Fp>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sHasherPallas = super::Blake2sHasher<Fp>;
+
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonDomainPallas = super::PoseidonDomain<Fp>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonFunctionPallas = super::PoseidonFunction<Fp>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonHasherPallas = super::PoseidonHasher<Fp>;
+
+    #[cfg(feature = "sha256")]
+    pub type Sha256DomainPallas = super::Sha256Domain<Fp>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256FunctionPallas = super::Sha256Function<Fp>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256HasherPallas = super::Sha256Hasher<Fp>;
+
+    // Vesta
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sDomainVesta = super::Blake2sDomain<Fq>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sFunctionVesta = super::Blake2sFunction<Fq>;
+    #[cfg(feature = "blake2s")]
+    pub type Blake2sHasherVesta = super::Blake2sHasher<Fq>;
+
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonDomainVesta = super::PoseidonDomain<Fq>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonFunctionVesta = super::PoseidonFunction<Fq>;
+    #[cfg(feature = "poseidon")]
+    pub type PoseidonHasherVesta = super::PoseidonHasher<Fq>;
+
+    #[cfg(feature = "sha256")]
+    pub type Sha256DomainVesta = super::Sha256Domain<Fq>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256FunctionVesta = super::Sha256Function<Fq>;
+    #[cfg(feature = "sha256")]
+    pub type Sha256HasherVesta = super::Sha256Hasher<Fq>;
+}
diff --git a/filecoin-hashers/src/generic/poseidon.rs b/filecoin-hashers/src/generic/poseidon.rs
new file mode 100644
index 000000000..b5c8c9dfb
--- /dev/null
+++ b/filecoin-hashers/src/generic/poseidon.rs
@@ -0,0 +1,688 @@
+use std::cmp::Ordering;
+use std::marker::PhantomData;
+
+use bellperson::{
+    gadgets::{boolean::Boolean, num::AllocatedNum},
+    ConstraintSystem, SynthesisError,
+};
+use blstrs::Scalar as Fr;
+use ff::{Field, PrimeField};
+use generic_array::typenum::{Unsigned, U11, U2, U4, U8};
+use lazy_static::lazy_static;
+use merkletree::{
+    hash::{Algorithm, Hashable},
+    merkle::Element,
+};
+use neptune::{circuit::poseidon_hash, poseidon::PoseidonConstants, Arity, Poseidon};
+use pasta_curves::{Fp, Fq};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use typemap::ShareMap;
+
+use crate::{Domain, HashFunction, Hasher, PoseidonArity, PoseidonMDArity};
+
+lazy_static! {
+    pub static ref POSEIDON_CONSTANTS_2: PoseidonConstants::<Fr, U2> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_4: PoseidonConstants::<Fr, U4> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_8: PoseidonConstants::<Fr, U8> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_11: PoseidonConstants::<Fr, U11> = PoseidonConstants::new();
+    pub static ref POSEIDON_MD_CONSTANTS: PoseidonConstants::<Fr, PoseidonMDArity> =
+        PoseidonConstants::new();
+
+    pub static ref POSEIDON_CONSTANTS_2_PALLAS: PoseidonConstants::<Fp, U2> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_4_PALLAS: PoseidonConstants::<Fp, U4> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_8_PALLAS: PoseidonConstants::<Fp, U8> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_11_PALLAS: PoseidonConstants::<Fp, U11> = PoseidonConstants::new();
+    pub static ref POSEIDON_MD_CONSTANTS_PALLAS: PoseidonConstants::<Fp, PoseidonMDArity> =
+        PoseidonConstants::new();
+
+    pub static ref POSEIDON_CONSTANTS_2_VESTA: PoseidonConstants::<Fq, U2> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_4_VESTA: PoseidonConstants::<Fq, U4> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_8_VESTA: PoseidonConstants::<Fq, U8> = PoseidonConstants::new();
+    pub static ref POSEIDON_CONSTANTS_11_VESTA: PoseidonConstants::<Fq, U11> = PoseidonConstants::new();
+    pub static ref POSEIDON_MD_CONSTANTS_VESTA: PoseidonConstants::<Fq, PoseidonMDArity> =
+        PoseidonConstants::new();
+
+    pub static ref POSEIDON_CONSTANTS: ShareMap = {
+        let mut tm = ShareMap::custom();
+
+        tm.insert::<FieldArity<Fr, U2>>(&*POSEIDON_CONSTANTS_2);
+        tm.insert::<FieldArity<Fr, U4>>(&*POSEIDON_CONSTANTS_4);
+        tm.insert::<FieldArity<Fr, U8>>(&*POSEIDON_CONSTANTS_8);
+        tm.insert::<FieldArity<Fr, U11>>(&*POSEIDON_CONSTANTS_11);
+        tm.insert::<FieldArity<Fr, PoseidonMDArity>>(&*POSEIDON_MD_CONSTANTS);
+
+        tm.insert::<FieldArity<Fp, U2>>(&*POSEIDON_CONSTANTS_2_PALLAS);
+        tm.insert::<FieldArity<Fp, U4>>(&*POSEIDON_CONSTANTS_4_PALLAS);
+        tm.insert::<FieldArity<Fp, U8>>(&*POSEIDON_CONSTANTS_8_PALLAS);
+        tm.insert::<FieldArity<Fp, U11>>(&*POSEIDON_CONSTANTS_11_PALLAS);
+        tm.insert::<FieldArity<Fp, PoseidonMDArity>>(&*POSEIDON_MD_CONSTANTS_PALLAS);
+
+        tm.insert::<FieldArity<Fq, U2>>(&*POSEIDON_CONSTANTS_2_VESTA);
+        tm.insert::<FieldArity<Fq, U4>>(&*POSEIDON_CONSTANTS_4_VESTA);
+        tm.insert::<FieldArity<Fq, U8>>(&*POSEIDON_CONSTANTS_8_VESTA);
+        tm.insert::<FieldArity<Fq, U11>>(&*POSEIDON_CONSTANTS_11_VESTA);
+        tm.insert::<FieldArity<Fq, PoseidonMDArity>>(&*POSEIDON_MD_CONSTANTS_VESTA);
+
+        tm
+    };
+}
+
+pub struct FieldArity<F, A>(PhantomData<(F, A)>)
+where
+    F: PrimeField,
+    A: Arity<F>;
+
+impl<F, A> typemap::Key for FieldArity<F, A>
+where
+    F: PrimeField,
+    A: Arity<F>,
+{
+    type Value = &'static PoseidonConstants<F, A>;
+}
+
+#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+pub struct PoseidonDomain<F: PrimeField<Repr = [u8; 32]>>(pub <F as PrimeField>::Repr);
+
+// Don't blanket `impl<F> From<F> for PoseidonDomain<F> where F: PrimeField` because `PrimeField` is
+// an externally defined trait which can have external implementors (which can result in conflicting
+// implementations), e.g. if we blanket impl `impl From<[u8; 32]> for PoseidonDomain<F> where F:
+// PrimeField` because `[u8; 32]` can implement `PrimeField`.
+impl From<Fr> for PoseidonDomain<Fr> {
+    fn from(f: Fr) -> Self {
+        PoseidonDomain(f.to_repr())
+    }
+}
+impl From<Fp> for PoseidonDomain<Fp> {
+    fn from(f: Fp) -> Self {
+        PoseidonDomain(f.to_repr())
+    }
+}
+impl From<Fq> for PoseidonDomain<Fq> {
+    fn from(f: Fq) -> Self {
+        PoseidonDomain(f.to_repr())
+    }
+}
+
+impl Into<Fr> for PoseidonDomain<Fr> {
+    fn into(self) -> Fr {
+        Fr::from_repr_vartime(self.0).expect("from_repr failure")
+    }
+}
+impl Into<Fp> for PoseidonDomain<Fp> {
+    fn into(self) -> Fp {
+        Fp::from_repr_vartime(self.0).expect("from_repr failure")
+    }
+}
+impl Into<Fq> for PoseidonDomain<Fq> {
+    fn into(self) -> Fq {
+        Fq::from_repr_vartime(self.0).expect("from_repr failure")
+    }
+}
+
+impl From<Fr> for PoseidonDomain<Fp> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::PoseidonDomain (Pallas)")
+    }
+}
+impl From<Fr> for PoseidonDomain<Fq> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::PoseidonDomain (Vesta)")
+    }
+}
+
+impl Into<Fr> for PoseidonDomain<Fp> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::PoseidonDomain (Pallas) into BLS12-381 scalar");
+    }
+}
+impl Into<Fr> for PoseidonDomain<Fq> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::PoseidonDomain (Vesta) into BLS12-381 scalar");
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> From<[u8; 32]> for PoseidonDomain<F> {
+    fn from(bytes: [u8; 32]) -> Self {
+        PoseidonDomain(bytes)
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<[u8]> for PoseidonDomain<F> {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<Self> for PoseidonDomain<F> {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+// Impl `PartialOrd` and `Ord` by hand because we can't derive them due to `F: PrimeField` not
+// implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> PartialOrd for PoseidonDomain<F> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.0.partial_cmp(&other.0)
+    }
+}
+impl<F: PrimeField<Repr = [u8; 32]>> Ord for PoseidonDomain<F> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.0.cmp(&other.0)
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Element for PoseidonDomain<F> {
+    fn byte_len() -> usize {
+        32
+    }
+
+    fn from_slice(bytes: &[u8]) -> Self {
+        assert_eq!(bytes.len(), Self::byte_len(), "invalid number of bytes");
+        let mut repr = [0u8; 32];
+        repr.copy_from_slice(bytes);
+        repr.into()
+    }
+
+    fn copy_to_slice(&self, bytes: &mut [u8]) {
+        bytes.copy_from_slice(&self.0);
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> std::hash::Hash for PoseidonDomain<F> {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        std::hash::Hash::hash(&self.0, hasher);
+    }
+}
+
+// Implement `Serialize` and `Deserialize` by hand because we can't derive them due to `F:
+// PrimeField` not implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> Serialize for PoseidonDomain<F> {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        self.0.serialize(s)
+    }
+}
+impl<'de, F: PrimeField<Repr = [u8; 32]>> Deserialize<'de> for PoseidonDomain<F> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        <[u8; 32]>::deserialize(d).map(Into::into)
+    }
+}
+
+impl Domain for PoseidonDomain<Fr> {
+    type Field = Fr;
+}
+
+impl Domain for PoseidonDomain<Fp> {
+    type Field = Fp;
+}
+
+impl Domain for PoseidonDomain<Fq> {
+    type Field = Fq;
+}
+
+fn shared_hash<F>(data: &[u8]) -> PoseidonDomain<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F>,
+{
+    // FIXME: We shouldn't unwrap here, but doing otherwise will require an interface change.
+    // We could truncate so `bytes_into_frs` cannot fail, then ensure `data` is always `fr_safe`.
+    let preimage: Vec<F> = data
+        .chunks(32)
+        .map(|chunk| {
+            let mut repr = [0u8; 32];
+            repr.copy_from_slice(chunk);
+            F::from_repr_vartime(repr).expect("from_repr failure")
+        })
+        .collect();
+
+    shared_hash_frs(&preimage).into()
+}
+
+fn shared_hash_frs<F: PrimeField<Repr = [u8; 32]>>(preimage: &[F]) -> F {
+    match preimage.len() {
+        2 => {
+            let consts = &POSEIDON_CONSTANTS
+                .get::<FieldArity<F, U2>>()
+                .expect("arity-2 Poseidon constants not found for field");
+            Poseidon::new_with_preimage(preimage, consts).hash()
+        }
+        4 => {
+            let consts = &POSEIDON_CONSTANTS
+                .get::<FieldArity<F, U4>>()
+                .expect("arity-4 Poseidon constants not found for field");
+            Poseidon::new_with_preimage(preimage, consts).hash()
+        }
+        8 => {
+            let consts = &POSEIDON_CONSTANTS
+                .get::<FieldArity<F, U8>>()
+                .expect("arity-8 Poseidon constants not found for field");
+            Poseidon::new_with_preimage(preimage, consts).hash()
+        }
+        n => panic!("unsupported arity for Poseidon hasher: {}", n),
+    }
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct PoseidonFunction<F>(F)
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F> + Into<F>;
+
+impl<F> std::hash::Hasher for PoseidonFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F> + Into<F>,
+{
+    fn write(&mut self, preimage: &[u8]) {
+        self.0 = shared_hash(preimage).into();
+    }
+
+    fn finish(&self) -> u64 {
+        unreachable!("unused by Function -- should never be called")
+    }
+}
+
+impl<F> Hashable<PoseidonFunction<F>> for PoseidonDomain<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F> + Into<F>,
+{
+    fn hash(&self, hasher: &mut PoseidonFunction<F>) {
+        <PoseidonFunction<F> as std::hash::Hasher>::write(hasher, self.as_ref())
+    }
+}
+
+// We can't blanket impl `Hashable for F where F: PrimeField` because both `Hashable` and `PrimeField`
+// are external traits, therefore we must implement `Hashable` by hand for each Pasta field.
+impl Hashable<PoseidonFunction<Fr>> for Fr {
+    fn hash(&self, hasher: &mut PoseidonFunction<Fr>) {
+        <PoseidonFunction<Fr> as std::hash::Hasher>::write(hasher, &self.to_repr())
+    }
+}
+impl Hashable<PoseidonFunction<Fp>> for Fp {
+    fn hash(&self, hasher: &mut PoseidonFunction<Fp>) {
+        <PoseidonFunction<Fp> as std::hash::Hasher>::write(hasher, &self.to_repr())
+    }
+}
+impl Hashable<PoseidonFunction<Fq>> for Fq {
+    fn hash(&self, hasher: &mut PoseidonFunction<Fq>) {
+        <PoseidonFunction<Fq> as std::hash::Hasher>::write(hasher, &self.to_repr())
+    }
+}
+
+impl<F> Algorithm<PoseidonDomain<F>> for PoseidonFunction<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F> + Into<F>,
+{
+    fn hash(&mut self) -> PoseidonDomain<F> {
+        self.0.into()
+    }
+
+    fn reset(&mut self) {
+        self.0 = F::zero();
+    }
+
+    fn leaf(&mut self, leaf: PoseidonDomain<F>) -> PoseidonDomain<F> {
+        leaf
+    }
+
+    fn node(
+        &mut self,
+        left: PoseidonDomain<F>,
+        right: PoseidonDomain<F>,
+        _height: usize,
+    ) -> PoseidonDomain<F> {
+        shared_hash_frs(&[left.into(), right.into()]).into()
+    }
+
+    fn multi_node(&mut self, preimage: &[PoseidonDomain<F>], _height: usize) -> PoseidonDomain<F> {
+        match preimage.len() {
+            2 | 4 | 8 => {
+                let preimage: Vec<F> = preimage
+                    .iter()
+                    .map(|domain| (*domain).into())
+                    .collect();
+                shared_hash_frs(&preimage).into()
+            }
+            arity => panic!("unsupported Halo Poseidon hasher arity: {}", arity),
+        }
+    }
+}
+
+impl HashFunction<PoseidonDomain<Fr>> for PoseidonFunction<Fr> {
+    fn hash(data: &[u8]) -> PoseidonDomain<Fr> {
+        shared_hash(data)
+    }
+
+    fn hash2(a: &PoseidonDomain<Fr>, b: &PoseidonDomain<Fr>) -> PoseidonDomain<Fr> {
+        let preimage = [(*a).into(), (*b).into()];
+        Poseidon::new_with_preimage(&preimage, &*POSEIDON_CONSTANTS_2).hash().into()
+    }
+
+    fn hash_md(input: &[PoseidonDomain<Fr>]) -> PoseidonDomain<Fr> {
+        assert!(
+            input.len() > 1,
+            "hash_md preimage must contain more than one element"
+        );
+
+        let arity = PoseidonMDArity::to_usize();
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fr, PoseidonMDArity>>()
+            .expect("Poseidon constants not found for field and arity-MD");
+
+        let mut p = Poseidon::new(consts);
+
+        let fr_input: Vec<Fr> = input.iter().map(|domain| (*domain).into()).collect();
+
+        fr_input[1..]
+            .chunks(arity - 1)
+            .fold(fr_input[0], |acc, frs| {
+                p.reset();
+                // Calling `.expect()` will panic iff we call `.input()` more that `arity` number
+                // of times prior to reseting the hasher (i.e. if we exceed the arity of the
+                // Poseidon constants) or if `preimge.len() == 1`; we prevent both scenarios.
+                p.input(acc).expect("input failure");
+                for fr in frs {
+                    p.input(*fr).expect("input failure");
+                }
+                p.hash()
+            })
+            .into()
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        cs: CS,
+        left: &AllocatedNum<Fr>,
+        right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        Self::hash2_circuit(cs, left, right)
+    }
+
+    fn hash_multi_leaf_circuit<Arity: 'static + PoseidonArity, CS: ConstraintSystem<Fr>>(
+        cs: CS,
+        leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fr, Arity>>()
+            .expect(&format!(
+                "arity-{} Poseidon constants not found for field",
+                Arity::to_usize(),
+            ));
+        poseidon_hash::<CS, Fr, Arity>(cs, leaves.to_vec(), consts)
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        cs: &mut CS,
+        elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let consts = &*POSEIDON_MD_CONSTANTS;
+        let arity = PoseidonMDArity::to_usize();
+
+        let mut hash = elements[0].clone();
+        let mut preimage = vec![hash.clone(); arity]; // Allocate. This will be overwritten.
+        for (hash_num, elts) in elements[1..].chunks(arity - 1).enumerate() {
+            preimage[0] = hash;
+            for (i, elt) in elts.iter().enumerate() {
+                preimage[i + 1] = elt.clone();
+            }
+            // any terminal padding
+            #[allow(clippy::needless_range_loop)]
+            for i in (elts.len() + 1)..arity {
+                preimage[i] =
+                    AllocatedNum::alloc(cs.namespace(|| format!("padding {}", i)), || {
+                        Ok(Fr::zero())
+                    })
+                    .expect("alloc failure");
+            }
+            let cs = cs.namespace(|| format!("hash md {}", hash_num));
+            hash = poseidon_hash::<_, Fr, PoseidonMDArity>(cs, preimage.clone(), consts)?.clone();
+        }
+
+        Ok(hash)
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!();
+    }
+
+    fn hash2_circuit<CS>(
+        cs: CS,
+        a: &AllocatedNum<Fr>,
+        b: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError>
+    where
+        CS: ConstraintSystem<Fr>,
+    {
+        let preimage = vec![a.clone(), b.clone()];
+        poseidon_hash::<CS, Fr, U2>(cs, preimage, &*POSEIDON_CONSTANTS_2)
+    }
+}
+
+impl HashFunction<PoseidonDomain<Fp>> for PoseidonFunction<Fp> {
+    fn hash(data: &[u8]) -> PoseidonDomain<Fp> {
+        shared_hash(data)
+    }
+
+    fn hash2(a: &PoseidonDomain<Fp>, b: &PoseidonDomain<Fp>) -> PoseidonDomain<Fp> {
+        let preimage = [(*a).into(), (*b).into()];
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fp, U2>>()
+            .expect("Poseidon constants not found for field and arity-2");
+        Poseidon::new_with_preimage(&preimage, consts).hash().into()
+    }
+
+    fn hash_md(input: &[PoseidonDomain<Fp>]) -> PoseidonDomain<Fp> {
+        assert!(
+            input.len() > 1,
+            "hash_md preimage must contain more than one element"
+        );
+
+        let arity = PoseidonMDArity::to_usize();
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fp, PoseidonMDArity>>()
+            .expect("Poseidon constants not found for field and arity-MD");
+
+        let mut p = Poseidon::new(consts);
+
+        let fr_input: Vec<Fp> = input.iter().map(|domain| (*domain).into()).collect();
+
+        fr_input[1..]
+            .chunks(arity - 1)
+            .fold(fr_input[0], |acc, frs| {
+                p.reset();
+                // Calling `.expect()` will panic iff we call `.input()` more that `arity` number
+                // of times prior to reseting the hasher (i.e. if we exceed the arity of the
+                // Poseidon constants) or if `preimge.len() == 1`; we prevent both scenarios.
+                p.input(acc).expect("input failure");
+                for fr in frs {
+                    p.input(*fr).expect("input failure");
+                }
+                p.hash()
+            })
+            .into()
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity: 'static + PoseidonArity, CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _a: &AllocatedNum<Fr>,
+        _b: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+}
+
+impl HashFunction<PoseidonDomain<Fq>> for PoseidonFunction<Fq> {
+    fn hash(data: &[u8]) -> PoseidonDomain<Fq> {
+        shared_hash(data)
+    }
+
+    fn hash2(a: &PoseidonDomain<Fq>, b: &PoseidonDomain<Fq>) -> PoseidonDomain<Fq> {
+        let preimage = [(*a).into(), (*b).into()];
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fq, U2>>()
+            .expect("Poseidon constants not found for field and arity-2");
+        Poseidon::new_with_preimage(&preimage, consts).hash().into()
+    }
+
+    fn hash_md(input: &[PoseidonDomain<Fq>]) -> PoseidonDomain<Fq> {
+        assert!(
+            input.len() > 1,
+            "hash_md preimage must contain more than one element"
+        );
+
+        let arity = PoseidonMDArity::to_usize();
+        let consts = &POSEIDON_CONSTANTS
+            .get::<FieldArity<Fq, PoseidonMDArity>>()
+            .expect("Poseidon constants not found for field and arity-MD");
+
+        let mut p = Poseidon::new(consts);
+
+        let fr_input: Vec<Fq> = input.iter().map(|domain| (*domain).into()).collect();
+
+        fr_input[1..]
+            .chunks(arity - 1)
+            .fold(fr_input[0], |acc, frs| {
+                p.reset();
+                // Calling `.expect()` will panic iff we call `.input()` more that `arity` number
+                // of times prior to reseting the hasher (i.e. if we exceed the arity of the
+                // Poseidon constants) or if `preimge.len() == 1`; we prevent both scenarios.
+                p.input(acc).expect("input failure");
+                for fr in frs {
+                    p.input(*fr).expect("input failure");
+                }
+                p.hash()
+            })
+            .into()
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity: 'static + PoseidonArity, CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _a: &AllocatedNum<Fr>,
+        _b: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::PoseidonFunction cannot be used within Groth16 circuits")
+    }
+}
+
+#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+pub struct PoseidonHasher<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    PoseidonDomain<F>: From<F> + Into<F>,
+{
+    _f: PhantomData<F>,
+}
+
+impl Hasher for PoseidonHasher<Fr> {
+    type Domain = PoseidonDomain<Fr>;
+    type Function = PoseidonFunction<Fr>;
+
+    fn name() -> String {
+        "poseidon_hasher".into()
+    }
+}
+
+impl Hasher for PoseidonHasher<Fp> {
+    type Domain = PoseidonDomain<Fp>;
+    type Function = PoseidonFunction<Fp>;
+
+    fn name() -> String {
+        "poseidon_pallas_hasher".into()
+    }
+}
+
+impl Hasher for PoseidonHasher<Fq> {
+    type Domain = PoseidonDomain<Fq>;
+    type Function = PoseidonFunction<Fq>;
+
+    fn name() -> String {
+        "poseidon_vesta_hasher".into()
+    }
+}
diff --git a/filecoin-hashers/src/generic/sha256.rs b/filecoin-hashers/src/generic/sha256.rs
new file mode 100644
index 000000000..df71d65c7
--- /dev/null
+++ b/filecoin-hashers/src/generic/sha256.rs
@@ -0,0 +1,582 @@
+use std::cmp::Ordering;
+use std::fmt::{self, Debug, Formatter};
+use std::marker::PhantomData;
+
+use bellperson::{
+    gadgets::{boolean::Boolean, multipack, num::AllocatedNum, sha256::sha256 as sha256_circuit},
+    ConstraintSystem, SynthesisError,
+};
+use blstrs::Scalar as Fr;
+use ff::PrimeField;
+use merkletree::{
+    hash::{Algorithm, Hashable},
+    merkle::Element,
+};
+use pasta_curves::{Fp, Fq};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use sha2::{Digest, Sha256};
+
+use crate::{Domain, Hasher, HashFunction};
+
+#[derive(Copy, Clone, PartialEq, Eq, Default)]
+pub struct Sha256Domain<F: PrimeField<Repr = [u8; 32]>> {
+    pub state: [u8; 32],
+    _f: PhantomData<F>,
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Debug for Sha256Domain<F> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Sha256Domain({})", hex::encode(&self.state))
+    }
+}
+
+// Don't blanket `impl<F> From<F> for Sha256Domain<F> where F: PrimeField` because `PrimeField` is
+// an externally defined trait which can have external implementors (which can result in conflicting
+// implementations), e.g. if we blanket impl `impl From<[u8; 32]> for Sha256Domain<F> where F:
+// PrimeField` because `[u8; 32]` can implement `PrimeField`.
+impl From<Fr> for Sha256Domain<Fr> {
+    fn from(f: Fr) -> Self {
+        Sha256Domain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+impl From<Fp> for Sha256Domain<Fp> {
+    fn from(f: Fp) -> Self {
+        Sha256Domain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+impl From<Fq> for Sha256Domain<Fq> {
+    fn from(f: Fq) -> Self {
+        Sha256Domain {
+            state: f.to_repr(),
+            _f: PhantomData,
+        }
+    }
+}
+
+impl Into<Fr> for Sha256Domain<Fr> {
+    fn into(self) -> Fr {
+        Fr::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+impl Into<Fp> for Sha256Domain<Fp> {
+    fn into(self) -> Fp {
+        Fp::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+impl Into<Fq> for Sha256Domain<Fq> {
+    fn into(self) -> Fq {
+        Fq::from_repr_vartime(self.state).expect("from_repr failure")
+    }
+}
+
+impl From<Fr> for Sha256Domain<Fp> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::Sha256Domain (Pallas)")
+    }
+}
+impl From<Fr> for Sha256Domain<Fq> {
+    fn from(_f: Fr) -> Self {
+        panic!("cannot convert BLS12-381 scalar to halo::Sha256Domain (Vesta)")
+    }
+}
+
+impl Into<Fr> for Sha256Domain<Fp> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::Sha256Domain (Pallas) into BLS12-381 scalar");
+    }
+}
+impl Into<Fr> for Sha256Domain<Fq> {
+    fn into(self) -> Fr {
+        panic!("cannot convert halo::Sha256Domain (Vesta) into BLS12-381 scalar");
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> From<[u8; 32]> for Sha256Domain<F> {
+    fn from(bytes: [u8; 32]) -> Self {
+        Sha256Domain {
+            state: bytes,
+            _f: PhantomData,
+        }
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<[u8]> for Sha256Domain<F> {
+    fn as_ref(&self) -> &[u8] {
+        &self.state
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> AsRef<Self> for Sha256Domain<F> {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+// Impl `PartialOrd` and `Ord` by hand because we can't derive them due to `F: PrimeField` not
+// implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> PartialOrd for Sha256Domain<F> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.state.partial_cmp(&other.state)
+    }
+}
+impl<F: PrimeField<Repr = [u8; 32]>> Ord for Sha256Domain<F> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.state.cmp(&other.state)
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Element for Sha256Domain<F> {
+    fn byte_len() -> usize {
+        32
+    }
+
+    fn from_slice(bytes: &[u8]) -> Self {
+        assert_eq!(bytes.len(), Self::byte_len(), "invalid number of bytes");
+        let mut state = [0u8; 32];
+        state.copy_from_slice(bytes);
+        state.into()
+    }
+
+    fn copy_to_slice(&self, bytes: &mut [u8]) {
+        bytes.copy_from_slice(&self.state);
+    }
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> std::hash::Hash for Sha256Domain<F> {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        std::hash::Hash::hash(&self.state, hasher);
+    }
+}
+
+// Implement `Serialize` and `Deserialize` by hand because we can't derive them due to `F:
+// PrimeField` not implementing them.
+impl<F: PrimeField<Repr = [u8; 32]>> Serialize for Sha256Domain<F> {
+    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        self.state.serialize(s)
+    }
+}
+impl<'de, F: PrimeField<Repr = [u8; 32]>> Deserialize<'de> for Sha256Domain<F> {
+    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        <[u8; 32]>::deserialize(d).map(Into::into)
+    }
+}
+
+/*
+impl<F> Domain for Sha256Domain<F>
+where
+    Self: From<F> + Into<F>,
+    F: PrimeField<Repr = [u8; 32]>,
+{
+    type Field = F;
+}
+*/
+impl Domain for Sha256Domain<Fr> {
+    type Field = Fr;
+}
+
+impl Domain for Sha256Domain<Fp> {
+    type Field = Fp;
+}
+
+impl Domain for Sha256Domain<Fq> {
+    type Field = Fq;
+}
+
+impl<F: PrimeField<Repr = [u8; 32]>> Sha256Domain<F> {
+    fn trim_to_fr32(&mut self) {
+        // Strip the last (most-signifigant) two bits to ensure that we state within the ~256-bit
+        // field `F`; note the fields `Fr`, `Fp`, and `Fq` are each 255-bit fields and fully utilize
+        // 254 bits, i.e. `254 < log2(field_modulus) < 255`.
+        self.state[31] &= 0b0011_1111;
+    }
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct Sha256Function<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Sha256Domain<F>: From<F> + Into<F>,
+{
+    hasher: Sha256,
+    _f: PhantomData<F>,
+}
+
+impl<F> std::hash::Hasher for Sha256Function<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Sha256Domain<F>: From<F> + Into<F>,
+{
+    fn write(&mut self, msg: &[u8]) {
+        self.hasher.update(msg);
+    }
+
+    fn finish(&self) -> u64 {
+        unreachable!("unused by Function -- should never be called");
+    }
+}
+
+impl<F> Hashable<Sha256Function<F>> for Sha256Domain<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Sha256Domain<F>: From<F> + Into<F>,
+{
+    fn hash(&self, hasher: &mut Sha256Function<F>) {
+        <Sha256Function<F> as std::hash::Hasher>::write(hasher, self.as_ref());
+    }
+}
+
+impl<F> Algorithm<Sha256Domain<F>> for Sha256Function<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Sha256Domain<F>: From<F> + Into<F>,
+{
+    fn hash(&mut self) -> Sha256Domain<F> {
+        let mut digest = [0u8; 32];
+        digest.copy_from_slice(self.hasher.clone().finalize().as_ref());
+        let mut trimmed: Sha256Domain<F> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn reset(&mut self) {
+        self.hasher.reset();
+    }
+
+    fn leaf(&mut self, leaf: Sha256Domain<F>) -> Sha256Domain<F> {
+        leaf
+    }
+
+    fn node(
+        &mut self,
+        left: Sha256Domain<F>,
+        right: Sha256Domain<F>,
+        _height: usize,
+    ) -> Sha256Domain<F> {
+        left.hash(self);
+        right.hash(self);
+        self.hash()
+    }
+
+    fn multi_node(&mut self, parts: &[Sha256Domain<F>], _height: usize) -> Sha256Domain<F> {
+        for part in parts {
+            part.hash(self);
+        }
+        self.hash()
+    }
+}
+
+// Specialized implementation of `HashFunction` over the BLS12-381 scalar field `Fr` because that
+// field is the only one which is compatible with `HashFunction`'s circuit inferfaces.
+impl HashFunction<Sha256Domain<Fr>> for Sha256Function<Fr> {
+    fn hash(data: &[u8]) -> Sha256Domain<Fr> {
+        let mut digest = [0u8; 32];
+        digest.copy_from_slice(Sha256::digest(data).as_ref());
+        let mut trimmed: Sha256Domain<Fr> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash2(a: &Sha256Domain<Fr>, b: &Sha256Domain<Fr>) -> Sha256Domain<Fr> {
+        let mut digest = [0u8; 32];
+        let hasher = Sha256::new()
+            .chain(AsRef::<[u8]>::as_ref(a))
+            .chain(AsRef::<[u8]>::as_ref(b));
+        digest.copy_from_slice(hasher.finalize().as_ref());
+        let mut trimmed: Sha256Domain<Fr> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut cs: CS,
+        leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let mut bits = Vec::with_capacity(leaves.len() * Fr::CAPACITY as usize);
+        for (i, leaf) in leaves.iter().enumerate() {
+            let mut padded = leaf.to_bits_le(cs.namespace(|| format!("{}_num_into_bits", i)))?;
+            while padded.len() % 8 != 0 {
+                padded.push(Boolean::Constant(false));
+            }
+
+            bits.extend(
+                padded
+                    .chunks_exact(8)
+                    .flat_map(|chunk| chunk.iter().rev())
+                    .cloned(),
+            );
+        }
+        Self::hash_circuit(cs, &bits)
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        cs: CS,
+        left: &[Boolean],
+        right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let mut preimage: Vec<Boolean> = vec![];
+
+        let mut left_padded = left.to_vec();
+        while left_padded.len() % 8 != 0 {
+            left_padded.push(Boolean::Constant(false));
+        }
+
+        preimage.extend(
+            left_padded
+                .chunks_exact(8)
+                .flat_map(|chunk| chunk.iter().rev())
+                .cloned(),
+        );
+
+        let mut right_padded = right.to_vec();
+        while right_padded.len() % 8 != 0 {
+            right_padded.push(Boolean::Constant(false));
+        }
+
+        preimage.extend(
+            right_padded
+                .chunks_exact(8)
+                .flat_map(|chunk| chunk.iter().rev())
+                .cloned(),
+        );
+
+        Self::hash_circuit(cs, &preimage[..])
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut cs: CS,
+        bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        let be_bits = sha256_circuit(cs.namespace(|| "hash"), bits)?;
+        let le_bits = be_bits
+            .chunks(8)
+            .flat_map(|chunk| chunk.iter().rev())
+            .cloned()
+            .take(Fr::CAPACITY as usize)
+            .collect::<Vec<_>>();
+        multipack::pack_bits(cs.namespace(|| "pack_le"), &le_bits)
+    }
+
+    fn hash2_circuit<CS>(
+        mut cs: CS,
+        a_num: &AllocatedNum<Fr>,
+        b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError>
+    where
+        CS: ConstraintSystem<Fr>,
+    {
+        // Allocate as booleans
+        let a = a_num.to_bits_le(cs.namespace(|| "a_bits"))?;
+        let b = b_num.to_bits_le(cs.namespace(|| "b_bits"))?;
+
+        let mut preimage: Vec<Boolean> = vec![];
+
+        let mut a_padded = a.to_vec();
+        while a_padded.len() % 8 != 0 {
+            a_padded.push(Boolean::Constant(false));
+        }
+
+        preimage.extend(
+            a_padded
+                .chunks_exact(8)
+                .flat_map(|chunk| chunk.iter().rev())
+                .cloned(),
+        );
+
+        let mut b_padded = b.to_vec();
+        while b_padded.len() % 8 != 0 {
+            b_padded.push(Boolean::Constant(false));
+        }
+
+        preimage.extend(
+            b_padded
+                .chunks_exact(8)
+                .flat_map(|chunk| chunk.iter().rev())
+                .cloned(),
+        );
+
+        Self::hash_circuit(cs, &preimage[..])
+    }
+}
+
+// Specialized implementation of `HashFunction` over the Pasta scalar fields `Fp` and `Fq` because
+// those fields are incompatible with `HashFunction`'s circuit inferfaces.
+impl HashFunction<Sha256Domain<Fp>> for Sha256Function<Fp> {
+    fn hash(data: &[u8]) -> Sha256Domain<Fp> {
+        let mut digest = [0u8; 32];
+        digest.copy_from_slice(Sha256::digest(data).as_ref());
+        let mut trimmed: Sha256Domain<Fp> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash2(a: &Sha256Domain<Fp>, b: &Sha256Domain<Fp>) -> Sha256Domain<Fp> {
+        let mut digest = [0u8; 32];
+        let hasher = Sha256::new()
+            .chain(AsRef::<[u8]>::as_ref(a))
+            .chain(AsRef::<[u8]>::as_ref(b));
+        digest.copy_from_slice(hasher.finalize().as_ref());
+        let mut trimmed: Sha256Domain<Fp> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _a_num: &AllocatedNum<Fr>,
+        _b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+}
+impl HashFunction<Sha256Domain<Fq>> for Sha256Function<Fq> {
+    fn hash(data: &[u8]) -> Sha256Domain<Fq> {
+        let mut digest = [0u8; 32];
+        digest.copy_from_slice(Sha256::digest(data).as_ref());
+        let mut trimmed: Sha256Domain<Fq> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash2(a: &Sha256Domain<Fq>, b: &Sha256Domain<Fq>) -> Sha256Domain<Fq> {
+        let mut digest = [0u8; 32];
+        let hasher = Sha256::new()
+            .chain(AsRef::<[u8]>::as_ref(a))
+            .chain(AsRef::<[u8]>::as_ref(b));
+        digest.copy_from_slice(hasher.finalize().as_ref());
+        let mut trimmed: Sha256Domain<Fq> = digest.into();
+        trimmed.trim_to_fr32();
+        trimmed
+    }
+
+    fn hash_leaf_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _left: &AllocatedNum<Fr>,
+        _right: &AllocatedNum<Fr>,
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_multi_leaf_circuit<Arity, CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _leaves: &[AllocatedNum<Fr>],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_md_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: &mut CS,
+        _elements: &[AllocatedNum<Fr>],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_leaf_bits_circuit<CS: ConstraintSystem<Fr>>(
+        _cs: CS,
+        _left: &[Boolean],
+        _right: &[Boolean],
+        _height: usize,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _bits: &[Boolean],
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+
+    fn hash2_circuit<CS: ConstraintSystem<Fr>>(
+        mut _cs: CS,
+        _a_num: &AllocatedNum<Fr>,
+        _b_num: &AllocatedNum<Fr>,
+    ) -> Result<AllocatedNum<Fr>, SynthesisError> {
+        unimplemented!("halo::Sha256Function cannot be used within Groth16 circuits")
+    }
+}
+
+#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+pub struct Sha256Hasher<F>
+where
+    F: PrimeField<Repr = [u8; 32]>,
+    Sha256Domain<F>: From<F> + Into<F>,
+{
+    _f: PhantomData<F>,
+}
+
+impl Hasher for Sha256Hasher<Fr> {
+    type Domain = Sha256Domain<Fr>;
+    type Function = Sha256Function<Fr>;
+
+    fn name() -> String {
+        "sha256_hasher".into()
+    }
+}
+
+impl Hasher for Sha256Hasher<Fp> {
+    type Domain = Sha256Domain<Fp>;
+    type Function = Sha256Function<Fp>;
+
+    fn name() -> String {
+        "sha256_pallas_hasher".into()
+    }
+}
+
+impl Hasher for Sha256Hasher<Fq> {
+    type Domain = Sha256Domain<Fq>;
+    type Function = Sha256Function<Fq>;
+
+    fn name() -> String {
+        "sha256_vesta_hasher".into()
+    }
+}
diff --git a/filecoin-hashers/src/lib.rs b/filecoin-hashers/src/lib.rs
index be76206d5..7dd24746b 100644
--- a/filecoin-hashers/src/lib.rs
+++ b/filecoin-hashers/src/lib.rs
@@ -6,6 +6,7 @@
 
 #[cfg(feature = "blake2s")]
 pub mod blake2s;
+pub mod generic;
 pub mod halo;
 #[cfg(feature = "poseidon")]
 pub mod poseidon;
diff --git a/filecoin-hashers/src/types.rs b/filecoin-hashers/src/types.rs
index 83cf3e570..311d0411b 100644
--- a/filecoin-hashers/src/types.rs
+++ b/filecoin-hashers/src/types.rs
@@ -4,6 +4,7 @@ use std::hash::Hash as StdHash;
 #[cfg(feature = "poseidon")]
 pub use crate::poseidon_types::*;
 
+use anyhow::ensure;
 use bellperson::{
     gadgets::{boolean::Boolean, num::AllocatedNum},
     ConstraintSystem, SynthesisError,
@@ -27,12 +28,15 @@ pub trait Domain:
     + Eq
     + Send
     + Sync
+    // Maintainig conversions to/from `Fr` limits interface breaking in other `rust-fil-proofs`
+    // member crates.
     + From<Fr>
-    + From<<Fr as PrimeField>::Repr>
     + Into<Fr>
+    // Note that `Self::Field` may be `Fr`, in which case the `From<Self::Field>` and
+    // `Into<Self::Field>` trait bounds are redundant.
     + From<Self::Field>
-    + From<[u8; 32]>
     + Into<Self::Field>
+    + From<[u8; 32]>
     + Serialize
     + DeserializeOwned
     + Element
@@ -41,10 +45,24 @@ pub trait Domain:
     type Field: PrimeField<Repr = [u8; 32]>;
 
     #[allow(clippy::wrong_self_convention)]
-    fn into_bytes(&self) -> Vec<u8>;
-    fn try_from_bytes(raw: &[u8]) -> anyhow::Result<Self>;
+    fn into_bytes(&self) -> Vec<u8> {
+        self.as_ref().to_vec()
+    }
+
+    fn try_from_bytes(bytes: &[u8]) -> anyhow::Result<Self> {
+        ensure!(bytes.len() == Self::byte_len(), "invalid number of bytes");
+        let mut array = [0u8; 32];
+        array.copy_from_slice(bytes);
+        Ok(array.into())
+    }
+
     /// Write itself into the given slice, LittleEndian bytes.
-    fn write_bytes(&self, _: &mut [u8]) -> anyhow::Result<()>;
+    fn write_bytes(&self, dest: &mut [u8]) -> anyhow::Result<()> {
+        let n = Self::byte_len();
+        ensure!(dest.len() >= n, "invalid number of bytes");
+        dest[..n].copy_from_slice(self.as_ref());
+        Ok(())
+    }
 
     fn random<R: RngCore>(rng: &mut R) -> Self {
         // Generating a field element then converting it ensures that we stay within the field.
@@ -52,26 +70,6 @@ pub trait Domain:
     }
 }
 
-/*
-pub trait GrothDomain: Domain<Field = Fr> {}
-
-impl<D> GrothDomain for D
-where
-    D: Domain<Field = Fr>,
-{}
-
-pub trait GrothHasher: Hasher
-where
-    Self::Domain: GrothDomain + Domain<Field = Fr>,
-{}
-
-impl<H> GrothHasher for H
-where
-    H: Hasher,
-    H::Domain: GrothDomain + Domain<Field = Fr>,
-{}
-*/
-
 pub trait HashFunction<T: Domain>: Clone + Debug + Send + Sync + LightAlgorithm<T> {
     fn hash(data: &[u8]) -> T;
     fn hash2(a: &T, b: &T) -> T;
diff --git a/storage-proofs-core/benches/drgraph.rs b/storage-proofs-core/benches/drgraph.rs
index a26a59853..fa649a4f9 100644
--- a/storage-proofs-core/benches/drgraph.rs
+++ b/storage-proofs-core/benches/drgraph.rs
@@ -1,29 +1,27 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use filecoin_hashers::{halo, poseidon::PoseidonHasher};
-use pasta_curves::{Fp, Fq};
+use filecoin_hashers::{generic::{groth, halo}, Hasher};
 use storage_proofs_core::{
     api_version::ApiVersion,
     drgraph::{BucketGraph, Graph, BASE_DEGREE},
 };
 
-// DRG parent-gen for the first and second nodes (node-indexes `0` and `1`) is different than
-// parent-gen for all other nodes (node-indexes `>= 2`).
-const CHILD_NODE: usize = 2;
-
-#[allow(clippy::unit_arg)]
-fn drgraph(c: &mut Criterion) {
+fn bench_for_hasher<H: Hasher>(c: &mut Criterion, hasher_name: &str) {
+    // Graph sizes to bench.
     let nodes = vec![12, 24, 128, 1024];
 
+    // The node to generate parents for; DRG parent-gen for the first and second nodes (node
+    // indexes `0` and `1`) is different than parent-gen for all other nodes (node-indexes `>= 2`).
+    let child: usize = 2;
+
     let mut group = c.benchmark_group("drg-parent-gen");
     for n in nodes {
-        group.bench_function(format!("deg={}-nodes={}-bls12", BASE_DEGREE, n), |b| {
+        group.bench_function(format!("deg={}-nodes={}-{}", BASE_DEGREE, n, hasher_name), |b| {
             let graph =
-                BucketGraph::<PoseidonHasher>::new(n, BASE_DEGREE, 0, [32; 32], ApiVersion::V1_1_0)
-                    .unwrap();
+                BucketGraph::<H>::new(n, BASE_DEGREE, 0, [32; 32], ApiVersion::V1_1_0).unwrap();
 
             b.iter(|| {
                 let mut parents = vec![0; BASE_DEGREE];
-                black_box(graph.parents(CHILD_NODE, &mut parents).unwrap());
+                black_box(graph.parents(child, &mut parents).unwrap());
             })
         });
     }
@@ -32,49 +30,11 @@ fn drgraph(c: &mut Criterion) {
 }
 
 #[allow(clippy::unit_arg)]
-fn drgraph_halo(c: &mut Criterion) {
-    let nodes = vec![12, 24, 128, 1024];
-
-    let mut group = c.benchmark_group("drg-parent-gen");
-
-    for n in &nodes {
-        group.bench_function(format!("deg={}-nodes={}-pallas", BASE_DEGREE, n), |b| {
-            let graph = BucketGraph::<halo::PoseidonHasher<Fp>>::new(
-                *n,
-                BASE_DEGREE,
-                0,
-                [32; 32],
-                ApiVersion::V1_1_0,
-            )
-            .unwrap();
-
-            b.iter(|| {
-                let mut parents = vec![0; BASE_DEGREE];
-                black_box(graph.parents(CHILD_NODE, &mut parents).unwrap());
-            })
-        });
-    }
-
-    for n in nodes {
-        group.bench_function(format!("deg={}-nodes={}-vesta", BASE_DEGREE, n), |b| {
-            let graph = BucketGraph::<halo::PoseidonHasher<Fq>>::new(
-                n,
-                BASE_DEGREE,
-                0,
-                [32; 32],
-                ApiVersion::V1_1_0,
-            )
-            .unwrap();
-
-            b.iter(|| {
-                let mut parents = vec![0; BASE_DEGREE];
-                black_box(graph.parents(CHILD_NODE, &mut parents).unwrap());
-            })
-        });
-    }
-
-    group.finish();
+fn drgraph(c: &mut Criterion) {
+    bench_for_hasher::<groth::PoseidonHasher>(c, "bls");
+    bench_for_hasher::<halo::PoseidonHasherPallas>(c, "pallas");
+    bench_for_hasher::<halo::PoseidonHasherVesta>(c, "vesta");
 }
 
-criterion_group!(benches, drgraph, drgraph_halo);
+criterion_group!(benches, drgraph);
 criterion_main!(benches);
diff --git a/storage-proofs-core/benches/merkle.rs b/storage-proofs-core/benches/merkle.rs
index 826012035..2341056b8 100644
--- a/storage-proofs-core/benches/merkle.rs
+++ b/storage-proofs-core/benches/merkle.rs
@@ -1,13 +1,9 @@
-use anyhow::Result;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use filecoin_hashers::{
-    halo, poseidon::PoseidonDomain, poseidon::PoseidonHasher, sha256::Sha256Hasher, Domain,
-};
-use pasta_curves::{Fp, Fq};
-use rand::{thread_rng, Rng};
+use filecoin_hashers::{generic::{groth, halo}, Domain, Hasher};
+use rand::thread_rng;
 use storage_proofs_core::merkle::{create_base_merkle_tree, BinaryMerkleTree};
 
-fn merkle_benchmark_sha256(c: &mut Criterion) {
+fn bench_with_hasher<H: 'static + Hasher>(c: &mut Criterion, hasher_name: &str) {
     let params = if cfg!(feature = "big-sector-sizes-bench") {
         vec![128, 1024, 1_048_576]
     } else {
@@ -16,13 +12,14 @@ fn merkle_benchmark_sha256(c: &mut Criterion) {
 
     let mut group = c.benchmark_group("merkletree-binary");
     for n_nodes in params {
-        group.bench_function(format!("sha256-{}", n_nodes), |b| {
+        group.bench_function(format!("nodes={}-{}", n_nodes, hasher_name), |b| {
             let mut rng = thread_rng();
-            let data: Vec<u8> = (0..32 * n_nodes).map(|_| rng.gen()).collect();
+            let data: Vec<u8> = (0..n_nodes)
+                .flat_map(|_| H::Domain::random(&mut rng).into_bytes())
+                .collect();
             b.iter(|| {
                 black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<Sha256Hasher>>(None, n_nodes, &data)
-                        .unwrap(),
+                    create_base_merkle_tree::<BinaryMerkleTree<H>>(None, n_nodes, &data).unwrap(),
                 )
             })
         });
@@ -31,160 +28,15 @@ fn merkle_benchmark_sha256(c: &mut Criterion) {
     group.finish();
 }
 
-fn merkle_benchmark_poseidon(c: &mut Criterion) {
-    let params = if cfg!(feature = "big-sector-sizes-bench") {
-        vec![64, 128, 1024, 1_048_576]
-    } else {
-        vec![64, 128, 1024]
-    };
-
-    let mut group = c.benchmark_group("merkletree-binary");
-    for n_nodes in params {
-        group.bench_function(format!("poseidon-{}", n_nodes), |b| {
-            let mut rng = thread_rng();
-            let mut data: Vec<u8> = Vec::with_capacity(32 * n_nodes);
-            (0..n_nodes)
-                .into_iter()
-                .try_for_each(|_| -> Result<()> {
-                    let node = PoseidonDomain::random(&mut rng);
-                    data.extend(node.into_bytes());
-                    Ok(())
-                })
-                .expect("failed to generate data");
-
-            b.iter(|| {
-                black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<PoseidonHasher>>(
-                        None, n_nodes, &data,
-                    )
-                    .unwrap(),
-                )
-            })
-        });
-    }
-
-    group.finish();
-}
+fn merkle_benchmark(c: &mut Criterion) {
+    bench_with_hasher::<groth::Sha256Hasher>(c, "sha256-bls");
+    bench_with_hasher::<halo::Sha256HasherPallas>(c, "sha256-pallas");
+    bench_with_hasher::<halo::Sha256HasherVesta>(c, "sha256-vesta");
 
-fn merkle_benchmark_sha256_halo(c: &mut Criterion) {
-    let params = if cfg!(feature = "big-sector-sizes-bench") {
-        vec![64, 128, 1024, 1_048_576]
-    } else {
-        vec![64, 128, 1024]
-    };
-
-    let mut group = c.benchmark_group("merkletree-binary");
-    for n_nodes in params {
-        group.bench_function(format!("sha256-pallas-{}", n_nodes), |b| {
-            let mut rng = thread_rng();
-            let mut data: Vec<u8> = Vec::with_capacity(32 * n_nodes);
-            (0..n_nodes)
-                .into_iter()
-                .try_for_each(|_| -> Result<()> {
-                    let node = halo::Sha256Domain::<Fp>::random(&mut rng);
-                    data.extend(node.into_bytes());
-                    Ok(())
-                })
-                .expect("failed to generate data");
-
-            b.iter(|| {
-                black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<halo::Sha256Hasher<Fp>>>(
-                        None, n_nodes, &data,
-                    )
-                    .unwrap(),
-                )
-            })
-        });
-
-        group.bench_function(format!("sha256-vesta-{}", n_nodes), |b| {
-            let mut rng = thread_rng();
-            let mut data: Vec<u8> = Vec::with_capacity(32 * n_nodes);
-            (0..n_nodes)
-                .into_iter()
-                .try_for_each(|_| -> Result<()> {
-                    let node = halo::Sha256Domain::<Fq>::random(&mut rng);
-                    data.extend(node.into_bytes());
-                    Ok(())
-                })
-                .expect("failed to generate data");
-
-            b.iter(|| {
-                black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<halo::Sha256Hasher<Fq>>>(
-                        None, n_nodes, &data,
-                    )
-                    .unwrap(),
-                )
-            })
-        });
-    }
-
-    group.finish();
-}
-
-fn merkle_benchmark_poseidon_halo(c: &mut Criterion) {
-    let params = if cfg!(feature = "big-sector-sizes-bench") {
-        vec![64, 128, 1024, 1_048_576]
-    } else {
-        vec![64, 128, 1024]
-    };
-
-    let mut group = c.benchmark_group("merkletree-binary");
-    for n_nodes in params {
-        group.bench_function(format!("poseidon-pallas-{}", n_nodes), |b| {
-            let mut rng = thread_rng();
-            let mut data: Vec<u8> = Vec::with_capacity(32 * n_nodes);
-            (0..n_nodes)
-                .into_iter()
-                .try_for_each(|_| -> Result<()> {
-                    let node = halo::PoseidonDomain::<Fp>::random(&mut rng);
-                    data.extend(node.into_bytes());
-                    Ok(())
-                })
-                .expect("failed to generate data");
-
-            b.iter(|| {
-                black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<halo::PoseidonHasher<Fp>>>(
-                        None, n_nodes, &data,
-                    )
-                    .unwrap(),
-                )
-            })
-        });
-
-        group.bench_function(format!("poseidon-vesta-{}", n_nodes), |b| {
-            let mut rng = thread_rng();
-            let mut data: Vec<u8> = Vec::with_capacity(32 * n_nodes);
-            (0..n_nodes)
-                .into_iter()
-                .try_for_each(|_| -> Result<()> {
-                    let node = halo::PoseidonDomain::<Fq>::random(&mut rng);
-                    data.extend(node.into_bytes());
-                    Ok(())
-                })
-                .expect("failed to generate data");
-
-            b.iter(|| {
-                black_box(
-                    create_base_merkle_tree::<BinaryMerkleTree<halo::PoseidonHasher<Fq>>>(
-                        None, n_nodes, &data,
-                    )
-                    .unwrap(),
-                )
-            })
-        });
-    }
-
-    group.finish();
+    bench_with_hasher::<groth::PoseidonHasher>(c, "poseidon-bls");
+    bench_with_hasher::<halo::PoseidonHasherPallas>(c, "poseidon-pallas");
+    bench_with_hasher::<halo::PoseidonHasherVesta>(c, "poseidon-vesta");
 }
 
-criterion_group!(
-    benches,
-    merkle_benchmark_sha256,
-    merkle_benchmark_poseidon,
-    merkle_benchmark_sha256_halo,
-    merkle_benchmark_poseidon_halo,
-);
+criterion_group!(benches, merkle_benchmark);
 criterion_main!(benches);
diff --git a/storage-proofs-core/src/drgraph.rs b/storage-proofs-core/src/drgraph.rs
index 3bc6ff365..78296b5cd 100644
--- a/storage-proofs-core/src/drgraph.rs
+++ b/storage-proofs-core/src/drgraph.rs
@@ -255,13 +255,10 @@ pub fn derive_drg_seed(porep_id: PoRepID) -> [u8; 28] {
 mod tests {
     use super::*;
 
-    use filecoin_hashers::{
-        blake2s::Blake2sHasher, halo, poseidon::PoseidonHasher, sha256::Sha256Hasher,
-    };
+    use filecoin_hashers::generic::{groth, halo};
     use generic_array::typenum::{U0, U2, U4, U8};
     use memmap::{MmapMut, MmapOptions};
     use merkletree::store::StoreConfig;
-    use pasta_curves::{Fp, Fq};
 
     use crate::merkle::{
         create_base_merkle_tree, DiskStore, MerkleProofTrait, MerkleTreeTrait, MerkleTreeWrapper,
@@ -352,18 +349,16 @@ mod tests {
 
     #[test]
     fn graph_bucket_sha256() {
-        graph_bucket::<Sha256Hasher>();
+        graph_bucket::<groth::Sha256Hasher>();
+        graph_bucket::<halo::Sha256HasherPallas>();
+        graph_bucket::<halo::Sha256HasherVesta>();
     }
 
     #[test]
     fn graph_bucket_blake2s() {
-        graph_bucket::<Blake2sHasher>();
-    }
-
-    #[test]
-    fn graph_bucket_sha256_halo() {
-        graph_bucket::<halo::Sha256Hasher<Fp>>();
-        graph_bucket::<halo::Sha256Hasher<Fq>>();
+        graph_bucket::<groth::Blake2sHasher>();
+        graph_bucket::<halo::Blake2sHasherPallas>();
+        graph_bucket::<halo::Blake2sHasherVesta>();
     }
 
     fn gen_proof<H: 'static + Hasher, U: 'static + PoseidonArity>(config: Option<StoreConfig>) {
@@ -388,66 +383,50 @@ mod tests {
 
     #[test]
     fn gen_proof_poseidon_binary() {
-        gen_proof::<PoseidonHasher, U2>(None);
+        gen_proof::<groth::PoseidonHasher, U2>(None);
+        gen_proof::<halo::PoseidonHasherPallas, U2>(None);
+        gen_proof::<halo::PoseidonHasherVesta, U2>(None);
     }
 
     #[test]
     fn gen_proof_sha256_binary() {
-        gen_proof::<Sha256Hasher, U2>(None);
+        gen_proof::<groth::Sha256Hasher, U2>(None);
+        gen_proof::<halo::Sha256HasherPallas, U2>(None);
+        gen_proof::<halo::Sha256HasherVesta, U2>(None);
     }
 
     #[test]
     fn gen_proof_blake2s_binary() {
-        gen_proof::<Blake2sHasher, U2>(None);
-    }
-
-    #[test]
-    fn gen_proof_poseidon_binary_halo() {
-        gen_proof::<halo::PoseidonHasher<Fp>, U2>(None);
-        gen_proof::<halo::PoseidonHasher<Fq>, U2>(None);
-    }
-
-    #[test]
-    fn gen_proof_sha256_binary_halo() {
-        gen_proof::<halo::Sha256Hasher<Fp>, U2>(None);
-        gen_proof::<halo::Sha256Hasher<Fq>, U2>(None);
+        gen_proof::<groth::Blake2sHasher, U2>(None);
+        gen_proof::<halo::Blake2sHasherPallas, U2>(None);
+        gen_proof::<halo::Blake2sHasherVesta, U2>(None);
     }
 
     #[test]
     fn gen_proof_poseidon_quad() {
-        gen_proof::<PoseidonHasher, U4>(None);
+        gen_proof::<groth::PoseidonHasher, U4>(None);
+        gen_proof::<halo::PoseidonHasherPallas, U4>(None);
+        gen_proof::<halo::PoseidonHasherVesta, U4>(None);
     }
 
     #[test]
     fn gen_proof_sha256_quad() {
-        gen_proof::<Sha256Hasher, U4>(None);
+        gen_proof::<groth::Sha256Hasher, U4>(None);
+        gen_proof::<halo::Sha256HasherPallas, U4>(None);
+        gen_proof::<halo::Sha256HasherVesta, U4>(None);
     }
 
     #[test]
     fn gen_proof_blake2s_quad() {
-        gen_proof::<Blake2sHasher, U4>(None);
-    }
-
-    #[test]
-    fn gen_proof_poseidon_quad_halo() {
-        gen_proof::<halo::PoseidonHasher<Fp>, U4>(None);
-        gen_proof::<halo::PoseidonHasher<Fq>, U4>(None);
-    }
-
-    #[test]
-    fn gen_proof_sha256_quad_halo() {
-        gen_proof::<halo::Sha256Hasher<Fp>, U4>(None);
-        gen_proof::<halo::Sha256Hasher<Fq>, U4>(None);
+        gen_proof::<groth::Blake2sHasher, U4>(None);
+        gen_proof::<halo::Blake2sHasherPallas, U4>(None);
+        gen_proof::<halo::Blake2sHasherVesta, U4>(None);
     }
 
     #[test]
     fn gen_proof_poseidon_oct() {
-        gen_proof::<PoseidonHasher, U8>(None);
-    }
-
-    #[test]
-    fn gen_proof_poseidon_oct_halo() {
-        gen_proof::<halo::PoseidonHasher<Fp>, U8>(None);
-        gen_proof::<halo::PoseidonHasher<Fq>, U8>(None);
+        gen_proof::<groth::PoseidonHasher, U8>(None);
+        gen_proof::<halo::PoseidonHasherPallas, U8>(None);
+        gen_proof::<halo::PoseidonHasherVesta, U8>(None);
     }
 }
diff --git a/storage-proofs-core/src/merkle/proof.rs b/storage-proofs-core/src/merkle/proof.rs
index 0ebb509b4..9476b08ab 100644
--- a/storage-proofs-core/src/merkle/proof.rs
+++ b/storage-proofs-core/src/merkle/proof.rs
@@ -700,10 +700,13 @@ mod tests {
     use super::*;
 
     use filecoin_hashers::{
-        blake2s::Blake2sHasher, halo, poseidon::PoseidonHasher, sha256::Sha256Hasher, Domain,
+        generic::{
+            groth::{Blake2sHasher, PoseidonHasher, Sha256Hasher},
+            halo,
+        },
+        Domain,
     };
     use generic_array::typenum::{U2, U4, U8};
-    use pasta_curves::{Fp, Fq};
     use rand::thread_rng;
 
     use crate::merkle::{
@@ -905,221 +908,92 @@ mod tests {
 
     #[test]
     fn merklepath_poseidon_2_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U2,
-                U0,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U2,
-                U0,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U2, U0, U0>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_poseidon_4_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U4,
-                U0,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U4,
-                U0,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U4, U0, U0>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_poseidon_8_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U8,
-                U0,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U8,
-                U0,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U8, U0, U0>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_poseidon_8_2_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U8,
-                U2,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U8,
-                U2,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U8, U2, U0>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_poseidon_8_4_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U8,
-                U4,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U8,
-                U4,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U8, U4, U0>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_poseidon_8_4_2_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fp>,
-                DiskStore<<halo::PoseidonHasher<Fp> as Hasher>::Domain>,
-                U8,
-                U4,
-                U2,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::PoseidonHasher<Fq>,
-                DiskStore<<halo::PoseidonHasher<Fq> as Hasher>::Domain>,
-                U8,
-                U4,
-                U2,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U8, U4, U2>;
+        merklepath::<Tree<halo::PoseidonHasherPallas>>();
+        merklepath::<Tree<halo::PoseidonHasherVesta>>();
     }
 
     #[test]
     fn merklepath_sha256_2_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fp>,
-                DiskStore<<halo::Sha256Hasher<Fp> as Hasher>::Domain>,
-                U2,
-                U0,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fq>,
-                DiskStore<<halo::Sha256Hasher<Fq> as Hasher>::Domain>,
-                U2,
-                U0,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U2, U0, U0>;
+        merklepath::<Tree<halo::Sha256HasherPallas>>();
+        merklepath::<Tree<halo::Sha256HasherVesta>>();
     }
 
     #[test]
     fn merklepath_sha256_4_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fp>,
-                DiskStore<<halo::Sha256Hasher<Fp> as Hasher>::Domain>,
-                U4,
-                U0,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fq>,
-                DiskStore<<halo::Sha256Hasher<Fq> as Hasher>::Domain>,
-                U4,
-                U0,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U4, U0, U0>;
+        merklepath::<Tree<halo::Sha256HasherPallas>>();
+        merklepath::<Tree<halo::Sha256HasherVesta>>();
     }
 
     #[test]
     fn merklepath_sha256_2_4_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fp>,
-                DiskStore<<halo::Sha256Hasher<Fp> as Hasher>::Domain>,
-                U2,
-                U4,
-                U0,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fq>,
-                DiskStore<<halo::Sha256Hasher<Fq> as Hasher>::Domain>,
-                U2,
-                U4,
-                U0,
-            >,
-        >();
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U2, U4, U0>;
+        merklepath::<Tree<halo::Sha256HasherPallas>>();
+        merklepath::<Tree<halo::Sha256HasherVesta>>();
     }
 
     #[test]
-    fn merklepath_sha256_top_2_4_2_halo() {
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fp>,
-                DiskStore<<halo::Sha256Hasher<Fp> as Hasher>::Domain>,
-                U2,
-                U4,
-                U2,
-            >,
-        >();
-        merklepath::<
-            MerkleTreeWrapper<
-                halo::Sha256Hasher<Fq>,
-                DiskStore<<halo::Sha256Hasher<Fq> as Hasher>::Domain>,
-                U2,
-                U4,
-                U2,
-            >,
-        >();
+    fn merklepath_sha256_2_4_2_halo() {
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U2, U4, U2>;
+        merklepath::<Tree<halo::Sha256HasherPallas>>();
+        merklepath::<Tree<halo::Sha256HasherVesta>>();
+    }
+
+    #[test]
+    fn merklepath_blake2s_2_halo() {
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U2, U0, U0>;
+        merklepath::<Tree<halo::Blake2sHasherPallas>>();
+        merklepath::<Tree<halo::Blake2sHasherVesta>>();
+    }
+
+    #[test]
+    fn merklepath_blake2s_4_halo() {
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U4, U0, U0>;
+        merklepath::<Tree<halo::Blake2sHasherPallas>>();
+        merklepath::<Tree<halo::Blake2sHasherVesta>>();
+    }
+
+    #[test]
+    fn merklepath_blake2s_8_4_2_halo() {
+        type Tree<H> = MerkleTreeWrapper<H, DiskStore<<H as Hasher>::Domain>, U8, U4, U2>;
+        merklepath::<Tree<halo::Blake2sHasherPallas>>();
+        merklepath::<Tree<halo::Blake2sHasherVesta>>();
     }
 }
diff --git a/storage-proofs-core/tests/por_vanilla.rs b/storage-proofs-core/tests/por_vanilla.rs
index b887a1a00..ad092d76e 100644
--- a/storage-proofs-core/tests/por_vanilla.rs
+++ b/storage-proofs-core/tests/por_vanilla.rs
@@ -1,10 +1,13 @@
 use std::convert::Into;
 
 use filecoin_hashers::{
-    blake2s::Blake2sHasher, halo, poseidon::PoseidonHasher, sha256::Sha256Hasher, Domain, Hasher,
+    generic::{
+        groth::{Blake2sHasher, PoseidonHasher, Sha256Hasher},
+        halo,
+    },
+    Domain, Hasher,
 };
 use generic_array::typenum::{U0, U2, U4};
-use pasta_curves::{Fp, Fq};
 use rand::SeedableRng;
 use rand_xorshift::XorShiftRng;
 use storage_proofs_core::{
@@ -36,14 +39,14 @@ fn test_por_blake2s_base_2() {
 
 #[test]
 fn test_por_poseidon_base_2_halo() {
-    test_por::<TreeBase<halo::PoseidonHasher<Fp>, U2>>();
-    test_por::<TreeBase<halo::PoseidonHasher<Fq>, U2>>();
+    test_por::<TreeBase<halo::PoseidonHasherPallas, U2>>();
+    test_por::<TreeBase<halo::PoseidonHasherVesta, U2>>();
 }
 
 #[test]
 fn test_por_sha256_base_2_halo() {
-    test_por::<TreeBase<halo::Sha256Hasher<Fp>, U2>>();
-    test_por::<TreeBase<halo::Sha256Hasher<Fq>, U2>>();
+    test_por::<TreeBase<halo::Sha256HasherPallas, U2>>();
+    test_por::<TreeBase<halo::Sha256HasherVesta, U2>>();
 }
 
 #[test]
@@ -63,14 +66,14 @@ fn test_por_blake2s_base_4() {
 
 #[test]
 fn test_por_poseidon_base_4_halo() {
-    test_por::<TreeBase<halo::PoseidonHasher<Fp>, U4>>();
-    test_por::<TreeBase<halo::PoseidonHasher<Fq>, U4>>();
+    test_por::<TreeBase<halo::PoseidonHasherPallas, U4>>();
+    test_por::<TreeBase<halo::PoseidonHasherVesta, U4>>();
 }
 
 #[test]
 fn test_por_sha256_base_4_halo() {
-    test_por::<TreeBase<halo::Sha256Hasher<Fp>, U4>>();
-    test_por::<TreeBase<halo::Sha256Hasher<Fq>, U4>>();
+    test_por::<TreeBase<halo::Sha256HasherPallas, U4>>();
+    test_por::<TreeBase<halo::Sha256HasherVesta, U4>>();
 }
 
 fn test_por<Tree: MerkleTreeTrait>() {
@@ -128,14 +131,14 @@ fn test_por_validates_proof_poseidon_base_2() {
 
 #[test]
 fn test_por_validates_proof_sha256_base_2_halo() {
-    test_por_validates_proof::<TreeBase<halo::Sha256Hasher<Fp>, U2>>();
-    test_por_validates_proof::<TreeBase<halo::Sha256Hasher<Fq>, U2>>();
+    test_por_validates_proof::<TreeBase<halo::Sha256HasherPallas, U2>>();
+    test_por_validates_proof::<TreeBase<halo::Sha256HasherVesta, U2>>();
 }
 
 #[test]
 fn test_por_validates_proof_poseidon_base_2_halo() {
-    test_por_validates_proof::<TreeBase<halo::PoseidonHasher<Fp>, U2>>();
-    test_por_validates_proof::<TreeBase<halo::PoseidonHasher<Fq>, U2>>();
+    test_por_validates_proof::<TreeBase<halo::PoseidonHasherPallas, U2>>();
+    test_por_validates_proof::<TreeBase<halo::PoseidonHasherVesta, U2>>();
 }
 
 #[test]
@@ -155,14 +158,14 @@ fn test_por_validates_proof_poseidon_base_4() {
 
 #[test]
 fn test_por_validates_proof_sha256_base_4_halo() {
-    test_por_validates_proof::<TreeBase<halo::Sha256Hasher<Fp>, U4>>();
-    test_por_validates_proof::<TreeBase<halo::Sha256Hasher<Fq>, U4>>();
+    test_por_validates_proof::<TreeBase<halo::Sha256HasherPallas, U4>>();
+    test_por_validates_proof::<TreeBase<halo::Sha256HasherVesta, U4>>();
 }
 
 #[test]
 fn test_por_validates_proof_poseidon_base_4_halo() {
-    test_por_validates_proof::<TreeBase<halo::PoseidonHasher<Fp>, U4>>();
-    test_por_validates_proof::<TreeBase<halo::PoseidonHasher<Fq>, U4>>();
+    test_por_validates_proof::<TreeBase<halo::PoseidonHasherPallas, U4>>();
+    test_por_validates_proof::<TreeBase<halo::PoseidonHasherVesta, U4>>();
 }
 
 fn test_por_validates_proof<Tree: MerkleTreeTrait>() {
@@ -206,6 +209,7 @@ fn test_por_validates_proof<Tree: MerkleTreeTrait>() {
 
     // Invalidate the proof.
     let bad_proof = {
+        /*
         let mut bad_data = [0u8; 32];
         bad_data.copy_from_slice(good_proof.data.as_ref());
         bad_data[0] = bad_data[0].wrapping_add(1);
@@ -213,6 +217,13 @@ fn test_por_validates_proof<Tree: MerkleTreeTrait>() {
             data: bad_data.into(),
             proof: good_proof.proof,
         }
+        */
+        use ff::Field;
+        let mut proof = good_proof;
+        let mut bad_leaf: <<Tree::Hasher as Hasher>::Domain as Domain>::Field = proof.data.into();
+        bad_leaf += <<Tree::Hasher as Hasher>::Domain as Domain>::Field::one();
+        proof.data = bad_leaf.into();
+        proof
     };
 
     let verified =
@@ -238,14 +249,14 @@ fn test_por_validates_challenge_poseidon_base_2() {
 
 #[test]
 fn test_por_validates_challenge_sha256_base_2_halo() {
-    test_por_validates_challenge::<TreeBase<halo::Sha256Hasher<Fp>, U2>>();
-    test_por_validates_challenge::<TreeBase<halo::Sha256Hasher<Fq>, U2>>();
+    test_por_validates_challenge::<TreeBase<halo::Sha256HasherPallas, U2>>();
+    test_por_validates_challenge::<TreeBase<halo::Sha256HasherVesta, U2>>();
 }
 
 #[test]
 fn test_por_validates_challenge_poseidon_base_2_halo() {
-    test_por_validates_challenge::<TreeBase<halo::PoseidonHasher<Fp>, U2>>();
-    test_por_validates_challenge::<TreeBase<halo::PoseidonHasher<Fq>, U2>>();
+    test_por_validates_challenge::<TreeBase<halo::PoseidonHasherPallas, U2>>();
+    test_por_validates_challenge::<TreeBase<halo::PoseidonHasherVesta, U2>>();
 }
 
 #[test]
@@ -265,14 +276,14 @@ fn test_por_validates_challenge_poseidon_base_4() {
 
 #[test]
 fn test_por_validates_challenge_sha256_base_4_halo() {
-    test_por_validates_challenge::<TreeBase<halo::Sha256Hasher<Fp>, U4>>();
-    test_por_validates_challenge::<TreeBase<halo::Sha256Hasher<Fq>, U4>>();
+    test_por_validates_challenge::<TreeBase<halo::Sha256HasherPallas, U4>>();
+    test_por_validates_challenge::<TreeBase<halo::Sha256HasherVesta, U4>>();
 }
 
 #[test]
 fn test_por_validates_challenge_poseidon_base_4_halo() {
-    test_por_validates_challenge::<TreeBase<halo::PoseidonHasher<Fp>, U4>>();
-    test_por_validates_challenge::<TreeBase<halo::PoseidonHasher<Fq>, U4>>();
+    test_por_validates_challenge::<TreeBase<halo::PoseidonHasherPallas, U4>>();
+    test_por_validates_challenge::<TreeBase<halo::PoseidonHasherVesta, U4>>();
 }
 
 fn test_por_validates_challenge<Tree: MerkleTreeTrait>() {