diff --git a/fil-proofs-tooling/src/bin/benchy/prodbench.rs b/fil-proofs-tooling/src/bin/benchy/prodbench.rs
index ddb39be80b..73cd1cc2e2 100644
--- a/fil-proofs-tooling/src/bin/benchy/prodbench.rs
+++ b/fil-proofs-tooling/src/bin/benchy/prodbench.rs
@@ -272,7 +272,6 @@ fn run_measure_circuits(i: &ProdbenchInputs) -> CircuitOutputs {
 }
 
 fn measure_porep_circuit(i: &ProdbenchInputs) -> usize {
-    use storage_proofs::drgraph::new_seed;
     use storage_proofs::porep::stacked::{
         LayerChallenges, SetupParams, StackedCompound, StackedDrg,
     };
@@ -284,11 +283,12 @@ fn measure_porep_circuit(i: &ProdbenchInputs) -> usize {
     let nodes = (i.sector_size_bytes() / 32) as usize;
     let layer_challenges = LayerChallenges::new(layers, challenge_count);
 
+    let arbitrary_porep_id = [222; 32];
     let sp = SetupParams {
         nodes,
         degree: drg_degree,
         expansion_degree,
-        seed: new_seed(),
+        porep_id: arbitrary_porep_id,
         layer_challenges,
     };
 
diff --git a/fil-proofs-tooling/src/bin/benchy/stacked.rs b/fil-proofs-tooling/src/bin/benchy/stacked.rs
index d9f63865a0..60f5d7826e 100644
--- a/fil-proofs-tooling/src/bin/benchy/stacked.rs
+++ b/fil-proofs-tooling/src/bin/benchy/stacked.rs
@@ -120,11 +120,12 @@ where
         );
 
         let replica_id = H::Domain::random(rng);
+        let arbitrary_porep_id = [11; 32];
         let sp = stacked::SetupParams {
             nodes,
             degree: BASE_DEGREE,
             expansion_degree: EXP_DEGREE,
-            seed: new_seed(),
+            porep_id: arbitrary_porep_id,
             layer_challenges: layer_challenges.clone(),
         };
 
diff --git a/filecoin-proofs/src/parameters.rs b/filecoin-proofs/src/parameters.rs
index a98a7aa4d7..0946741be1 100644
--- a/filecoin-proofs/src/parameters.rs
+++ b/filecoin-proofs/src/parameters.rs
@@ -1,5 +1,4 @@
 use anyhow::{ensure, Result};
-use sha2::{Digest, Sha256};
 use storage_proofs::porep::stacked::{self, LayerChallenges, StackedDrg};
 use storage_proofs::post::fallback;
 use storage_proofs::proof::ProofScheme;
@@ -7,11 +6,6 @@ use storage_proofs::proof::ProofScheme;
 use crate::constants::*;
 use crate::types::{MerkleTreeTrait, PaddedBytesAmount, PoStConfig};
 
-const DRG_NONCE: [u8; 32] = [
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-    26, 27, 28, 30, 30, 31,
-];
-
 type WinningPostSetupParams = fallback::SetupParams;
 pub type WinningPostPublicParams = fallback::PublicParams;
 
@@ -74,15 +68,6 @@ pub fn window_post_setup_params(post_config: &PoStConfig) -> WindowPostSetupPara
     }
 }
 
-fn drg_seed_from_porep_id(porep_id: [u8; 32]) -> [u8; 28] {
-    let mut drg_seed = [0; 28];
-
-    let hash = Sha256::new().chain(porep_id).chain(DRG_NONCE).result();
-
-    drg_seed.copy_from_slice(&hash[..28]);
-    drg_seed
-}
-
 pub fn setup_params(
     sector_bytes: PaddedBytesAmount,
     partitions: usize,
@@ -113,13 +98,11 @@ pub fn setup_params(
     let degree = DRG_DEGREE;
     let expansion_degree = EXP_DEGREE;
 
-    let drg_seed = drg_seed_from_porep_id(porep_id);
-
     Ok(stacked::SetupParams {
         nodes,
         degree,
         expansion_degree,
-        seed: drg_seed,
+        porep_id,
         layer_challenges,
     })
 }
diff --git a/filecoin-proofs/src/pieces.rs b/filecoin-proofs/src/pieces.rs
index b86278b1c8..59e05b9918 100644
--- a/filecoin-proofs/src/pieces.rs
+++ b/filecoin-proofs/src/pieces.rs
@@ -356,7 +356,7 @@ mod tests {
     use paired::bls12_381::Fr;
     use rand::{Rng, RngCore, SeedableRng};
     use rand_xorshift::XorShiftRng;
-    use storage_proofs::drgraph::{new_seed, Graph};
+    use storage_proofs::drgraph::Graph;
     use storage_proofs::merkle::create_base_merkle_tree;
     use storage_proofs::porep::stacked::StackedBucketGraph;
 
@@ -698,11 +698,12 @@ mod tests {
         sector_size: SectorSize,
     ) -> Result<([u8; 32], Vec<PieceInfo>)> {
         let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
+        let porep_id = [32; 32];
         let graph = StackedBucketGraph::<DefaultPieceHasher>::new_stacked(
             u64::from(sector_size) as usize / NODE_SIZE,
             DRG_DEGREE,
             EXP_DEGREE,
-            new_seed(),
+            porep_id,
         )?;
 
         let mut staged_sector = Vec::with_capacity(u64::from(sector_size) as usize);
diff --git a/storage-proofs/core/src/crypto/mod.rs b/storage-proofs/core/src/crypto/mod.rs
index 45a3ab8e01..e9872f776b 100644
--- a/storage-proofs/core/src/crypto/mod.rs
+++ b/storage-proofs/core/src/crypto/mod.rs
@@ -1,5 +1,14 @@
+use sha2::{Digest, Sha256};
 pub mod aes;
 pub mod feistel;
 pub mod pedersen;
 pub mod sloth;
 pub mod xor;
+
+pub fn derive_porep_domain_seed(domain_separation_tag: &str, porep_id: [u8; 32]) -> [u8; 32] {
+    Sha256::new()
+        .chain(domain_separation_tag)
+        .chain(porep_id)
+        .result()
+        .into()
+}
diff --git a/storage-proofs/core/src/drgraph.rs b/storage-proofs/core/src/drgraph.rs
index 8bc058c3a8..056e02f758 100644
--- a/storage-proofs/core/src/drgraph.rs
+++ b/storage-proofs/core/src/drgraph.rs
@@ -7,6 +7,7 @@ use rand::{rngs::OsRng, Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use sha2::{Digest, Sha256};
 
+use crate::crypto::derive_porep_domain_seed;
 use crate::error::*;
 use crate::fr32::bytes_into_fr_repr_safe;
 use crate::hasher::{Hasher, PoseidonArity};
@@ -54,7 +55,7 @@ pub trait Graph<H: Hasher>: ::std::fmt::Debug + Clone + PartialEq + Eq {
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self>;
     fn seed(&self) -> [u8; 28];
 
@@ -203,7 +204,7 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self> {
         ensure!(expansion_degree == 0, "Expension degree must be zero.");
 
@@ -216,10 +217,14 @@ impl<H: Hasher> Graph<H> for BucketGraph<H> {
             "The number of metagraph nodes must be precisely castable to `f64`"
         );
 
+        let mut drg_seed = [0; 28];
+        let raw_seed = derive_porep_domain_seed("Filecoin_DRSample", porep_id);
+        drg_seed.copy_from_slice(&raw_seed[..28]);
+
         Ok(BucketGraph {
             nodes,
             base_degree,
-            seed,
+            seed: drg_seed,
             _h: PhantomData,
         })
     }
@@ -237,7 +242,6 @@ mod tests {
     use memmap::MmapOptions;
     use merkletree::store::StoreConfig;
 
-    use crate::drgraph::new_seed;
     use crate::hasher::{
         Blake2sHasher, PedersenHasher, PoseidonArity, PoseidonHasher, Sha256Hasher,
     };
@@ -257,9 +261,10 @@ mod tests {
 
     fn graph_bucket<H: Hasher>() {
         let degree = BASE_DEGREE;
+        let porep_id = [123; 32];
 
         for size in vec![4, 16, 256, 2048] {
-            let g = BucketGraph::<H>::new(size, degree, 0, new_seed()).unwrap();
+            let g = BucketGraph::<H>::new(size, degree, 0, porep_id).unwrap();
 
             assert_eq!(g.size(), size, "wrong nodes count");
 
@@ -309,7 +314,8 @@ mod tests {
 
     fn gen_proof<H: 'static + Hasher, U: 'static + PoseidonArity>(config: Option<StoreConfig>) {
         let leafs = 64;
-        let g = BucketGraph::<H>::new(leafs, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [1; 32];
+        let g = BucketGraph::<H>::new(leafs, BASE_DEGREE, 0, porep_id).unwrap();
         let data = vec![2u8; NODE_SIZE * leafs];
 
         let mmapped = &mmap_from(&data);
diff --git a/storage-proofs/core/src/por.rs b/storage-proofs/core/src/por.rs
index bcf58a62c2..43804dc094 100644
--- a/storage-proofs/core/src/por.rs
+++ b/storage-proofs/core/src/por.rs
@@ -156,7 +156,7 @@ mod tests {
     use rand::SeedableRng;
     use rand_xorshift::XorShiftRng;
 
-    use crate::drgraph::{new_seed, BucketGraph, Graph, BASE_DEGREE};
+    use crate::drgraph::{BucketGraph, Graph, BASE_DEGREE};
     use crate::fr32::fr_into_bytes;
     use crate::hasher::{Blake2sHasher, PedersenHasher, PoseidonHasher, Sha256Hasher};
     use crate::merkle::{create_base_merkle_tree, DiskStore, MerkleProofTrait, MerkleTreeWrapper};
@@ -174,8 +174,8 @@ mod tests {
         let data: Vec<u8> = (0..leaves)
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
-
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [3; 32];
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {
@@ -265,7 +265,9 @@ mod tests {
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
 
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [99; 32];
+
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {
@@ -350,7 +352,8 @@ mod tests {
             .flat_map(|_| fr_into_bytes(&Fr::random(rng)))
             .collect();
 
-        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, new_seed()).unwrap();
+        let porep_id = [32; 32];
+        let graph = BucketGraph::<Tree::Hasher>::new(leaves, BASE_DEGREE, 0, porep_id).unwrap();
         let tree = create_base_merkle_tree::<Tree>(None, graph.size(), data.as_slice()).unwrap();
 
         let pub_inputs = PublicInputs {
diff --git a/storage-proofs/porep/src/drg/circuit.rs b/storage-proofs/porep/src/drg/circuit.rs
index 270c769e1a..39692fbd02 100644
--- a/storage-proofs/porep/src/drg/circuit.rs
+++ b/storage-proofs/porep/src/drg/circuit.rs
@@ -314,7 +314,7 @@ mod tests {
     use storage_proofs_core::{
         cache_key::CacheKey,
         compound_proof,
-        drgraph::{graph_height, new_seed, BucketGraph, BASE_DEGREE},
+        drgraph::{graph_height, BucketGraph, BASE_DEGREE},
         fr32::{bytes_into_fr, fr_into_bytes},
         gadgets::TestConstraintSystem,
         hasher::PedersenHasher,
@@ -368,7 +368,7 @@ mod tests {
                 nodes,
                 degree,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,
diff --git a/storage-proofs/porep/src/drg/compound.rs b/storage-proofs/porep/src/drg/compound.rs
index 58ff665d18..3c1952879e 100644
--- a/storage-proofs/porep/src/drg/compound.rs
+++ b/storage-proofs/porep/src/drg/compound.rs
@@ -351,7 +351,7 @@ mod tests {
                     nodes,
                     degree,
                     expansion_degree: 0,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,
@@ -396,7 +396,7 @@ mod tests {
                     nodes,
                     degree,
                     expansion_degree: 0,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,
diff --git a/storage-proofs/porep/src/drg/vanilla.rs b/storage-proofs/porep/src/drg/vanilla.rs
index 1b97297b0a..89931635d2 100644
--- a/storage-proofs/porep/src/drg/vanilla.rs
+++ b/storage-proofs/porep/src/drg/vanilla.rs
@@ -80,8 +80,7 @@ pub struct DrgParams {
 
     pub expansion_degree: usize,
 
-    // Random seed
-    pub seed: [u8; 28],
+    pub porep_id: [u8; 32],
 }
 
 #[derive(Debug, Clone)]
@@ -250,7 +249,7 @@ where
             sp.drg.nodes,
             sp.drg.degree,
             sp.drg.expansion_degree,
-            sp.drg.seed,
+            sp.drg.porep_id,
         )?;
 
         Ok(PublicParams::new(graph, sp.private, sp.challenges_count))
@@ -652,7 +651,7 @@ mod tests {
                 nodes,
                 degree: BASE_DEGREE,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,
@@ -731,7 +730,7 @@ mod tests {
                 nodes: data.len() / 32,
                 degree: BASE_DEGREE,
                 expansion_degree: 0,
-                seed: new_seed(),
+                porep_id: [32; 32],
             },
             private: false,
             challenges_count: 1,
@@ -825,7 +824,7 @@ mod tests {
                     nodes,
                     degree,
                     expansion_degree,
-                    seed,
+                    porep_id: [32; 32],
                 },
                 private: false,
                 challenges_count: 2,
diff --git a/storage-proofs/porep/src/stacked/circuit/create_label.rs b/storage-proofs/porep/src/stacked/circuit/create_label.rs
index 3a73c1c735..6c1b0ddf9f 100644
--- a/storage-proofs/porep/src/stacked/circuit/create_label.rs
+++ b/storage-proofs/porep/src/stacked/circuit/create_label.rs
@@ -92,7 +92,7 @@ mod tests {
     use rand::SeedableRng;
     use rand_xorshift::XorShiftRng;
     use storage_proofs_core::{
-        drgraph::{new_seed, Graph, BASE_DEGREE},
+        drgraph::{Graph, BASE_DEGREE},
         fr32::{bytes_into_fr, fr_into_bytes},
         gadgets::TestConstraintSystem,
         hasher::Sha256Hasher,
@@ -110,12 +110,13 @@ mod tests {
         let rng = &mut XorShiftRng::from_seed(crate::TEST_SEED);
 
         let size = 64;
+        let porep_id = [32; 32];
 
         let graph = StackedBucketGraph::<Sha256Hasher>::new_stacked(
             size,
             BASE_DEGREE,
             EXP_DEGREE,
-            new_seed(),
+            porep_id,
         )
         .unwrap();
 
diff --git a/storage-proofs/porep/src/stacked/circuit/proof.rs b/storage-proofs/porep/src/stacked/circuit/proof.rs
index 36b1be7346..3d30b3381d 100644
--- a/storage-proofs/porep/src/stacked/circuit/proof.rs
+++ b/storage-proofs/porep/src/stacked/circuit/proof.rs
@@ -349,7 +349,7 @@ mod tests {
     use storage_proofs_core::{
         cache_key::CacheKey,
         compound_proof,
-        drgraph::{new_seed, BASE_DEGREE},
+        drgraph::BASE_DEGREE,
         fr32::fr_into_bytes,
         gadgets::{MetricCS, TestConstraintSystem},
         hasher::{Hasher, PedersenHasher, PoseidonHasher, Sha256Hasher},
@@ -423,7 +423,7 @@ mod tests {
             nodes,
             degree,
             expansion_degree,
-            seed: new_seed(),
+            porep_id: [32; 32],
             layer_challenges: layer_challenges.clone(),
         };
 
@@ -595,7 +595,7 @@ mod tests {
                 nodes,
                 degree,
                 expansion_degree,
-                seed: new_seed(),
+                porep_id: [32; 32],
                 layer_challenges: layer_challenges.clone(),
             },
             partitions: Some(partition_count),
diff --git a/storage-proofs/porep/src/stacked/vanilla/graph.rs b/storage-proofs/porep/src/stacked/vanilla/graph.rs
index 780d4f069b..f8941fd853 100644
--- a/storage-proofs/porep/src/stacked/vanilla/graph.rs
+++ b/storage-proofs/porep/src/stacked/vanilla/graph.rs
@@ -1,3 +1,4 @@
+use std::convert::TryInto;
 use std::marker::PhantomData;
 
 #[cfg(target_arch = "x86")]
@@ -11,7 +12,10 @@ use once_cell::sync::OnceCell;
 use rayon::prelude::*;
 use sha2raw::Sha256;
 use storage_proofs_core::{
-    crypto::feistel::{self, FeistelPrecomputed},
+    crypto::{
+        derive_porep_domain_seed,
+        feistel::{self, FeistelPrecomputed},
+    },
     drgraph::BASE_DEGREE,
     drgraph::{BucketGraph, Graph},
     error::Result,
@@ -114,6 +118,7 @@ where
 {
     expansion_degree: usize,
     base_graph: G,
+    feistel_keys: [feistel::Index; 4],
     feistel_precomputed: FeistelPrecomputed,
     id: String,
     cache: Option<&'static ParentCache>,
@@ -167,7 +172,7 @@ where
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self> {
         assert_eq!(base_degree, BASE_DEGREE);
         assert_eq!(expansion_degree, EXP_DEGREE);
@@ -177,10 +182,17 @@ where
 
         let base_graph = match base_graph {
             Some(graph) => graph,
-            None => G::new(nodes, base_degree, 0, seed)?,
+            None => G::new(nodes, base_degree, 0, porep_id)?,
         };
         let bg_id = base_graph.identifier();
 
+        let mut feistel_keys = [0u64; 4];
+        let raw_seed = derive_porep_domain_seed("Filecoin_Feistel", porep_id);
+        feistel_keys[0] = u64::from_le_bytes(raw_seed[0..8].try_into().unwrap());
+        feistel_keys[1] = u64::from_le_bytes(raw_seed[8..16].try_into().unwrap());
+        feistel_keys[2] = u64::from_le_bytes(raw_seed[16..24].try_into().unwrap());
+        feistel_keys[3] = u64::from_le_bytes(raw_seed[24..32].try_into().unwrap());
+
         let mut res = StackedGraph {
             base_graph,
             id: format!(
@@ -189,6 +201,7 @@ where
             ),
             expansion_degree,
             cache: None,
+            feistel_keys,
             feistel_precomputed: feistel::precompute((expansion_degree * nodes) as feistel::Index),
             _h: PhantomData,
         };
@@ -369,9 +382,9 @@ where
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self> {
-        Self::new_stacked(nodes, base_degree, expansion_degree, seed)
+        Self::new_stacked(nodes, base_degree, expansion_degree, porep_id)
     }
 
     fn create_key(
@@ -443,9 +456,9 @@ where
         nodes: usize,
         base_degree: usize,
         expansion_degree: usize,
-        seed: [u8; 28],
+        porep_id: [u8; 32],
     ) -> Result<Self> {
-        Self::new(None, nodes, base_degree, expansion_degree, seed)
+        Self::new(None, nodes, base_degree, expansion_degree, porep_id)
     }
 
     pub fn base_graph(&self) -> &G {
diff --git a/storage-proofs/porep/src/stacked/vanilla/params.rs b/storage-proofs/porep/src/stacked/vanilla/params.rs
index 665e2f2283..6dab03eadd 100644
--- a/storage-proofs/porep/src/stacked/vanilla/params.rs
+++ b/storage-proofs/porep/src/stacked/vanilla/params.rs
@@ -36,9 +36,9 @@ pub struct SetupParams {
 
     pub expansion_degree: usize,
 
-    // Random seed
-    pub seed: [u8; 28],
-
+    // // Random seed
+    // pub seed: [u8; 28],
+    pub porep_id: [u8; 32],
     pub layer_challenges: LayerChallenges,
 }
 
diff --git a/storage-proofs/porep/src/stacked/vanilla/proof.rs b/storage-proofs/porep/src/stacked/vanilla/proof.rs
index 1f409cf304..e2e8073aad 100644
--- a/storage-proofs/porep/src/stacked/vanilla/proof.rs
+++ b/storage-proofs/porep/src/stacked/vanilla/proof.rs
@@ -891,7 +891,7 @@ mod tests {
     use rand::{Rng, SeedableRng};
     use rand_xorshift::XorShiftRng;
     use storage_proofs_core::{
-        drgraph::{new_seed, BASE_DEGREE},
+        drgraph::BASE_DEGREE,
         fr32::fr_into_bytes,
         hasher::{Blake2sHasher, PedersenHasher, PoseidonHasher, Sha256Hasher},
         merkle::MerkleTreeTrait,
@@ -1011,7 +1011,7 @@ mod tests {
             nodes,
             degree: BASE_DEGREE,
             expansion_degree: EXP_DEGREE,
-            seed: new_seed(),
+            porep_id: [32; 32],
             layer_challenges: challenges.clone(),
         };
 
@@ -1188,7 +1188,7 @@ mod tests {
             nodes,
             degree,
             expansion_degree,
-            seed: new_seed(),
+            porep_id: [32; 32],
             layer_challenges: challenges.clone(),
         };
 
@@ -1269,7 +1269,7 @@ mod tests {
             nodes,
             degree,
             expansion_degree,
-            seed: new_seed(),
+            porep_id: [32; 32],
             layer_challenges: layer_challenges.clone(),
         };
 
diff --git a/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs b/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs
index d9ab40ffe4..6409009bca 100644
--- a/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs
+++ b/storage-proofs/porep/src/stacked/vanilla/proof_scheme.rs
@@ -31,7 +31,7 @@ impl<'a, 'c, Tree: 'static + MerkleTreeTrait, G: 'static + Hasher> ProofScheme<'
             sp.nodes,
             sp.degree,
             sp.expansion_degree,
-            sp.seed,
+            sp.porep_id,
         )?;
 
         Ok(PublicParams::new(graph, sp.layer_challenges.clone()))